{"id":19477264,"url":"https://github.com/ogshawnlee/pino-lang","last_synced_at":"2026-05-13T01:31:20.985Z","repository":{"id":223990636,"uuid":"759151946","full_name":"OGShawnLee/pino-lang","owner":"OGShawnLee","description":"Simple and aesthetic programming language built with C++ that intends to turn programming a joyful experience. Currently transpiled to JavaScript/Python as I don't know how to compile to a lower level.","archived":false,"fork":false,"pushed_at":"2025-04-05T17:09:13.000Z","size":403,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-11-19T01:02:53.961Z","etag":null,"topics":["javascript","programming-language","transpiled-language"],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/OGShawnLee.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2024-02-17T19:39:46.000Z","updated_at":"2025-04-05T17:09:16.000Z","dependencies_parsed_at":"2024-03-28T19:41:23.227Z","dependency_job_id":"84d3fc12-48f5-491c-9ded-8db9838e95f2","html_url":"https://github.com/OGShawnLee/pino-lang","commit_stats":null,"previous_names":["ogshawnlee/pino-lang"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/OGShawnLee/pino-lang","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/OGShawnLee%2Fpino-lang","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/OGShawnLee%2Fpino-lang/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/OGShawnLee%2Fpino-lang/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/OGShawnLee%2Fpino-lang/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/OGShawnLee","download_url":"https://codeload.github.com/OGShawnLee/pino-lang/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/OGShawnLee%2Fpino-lang/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":32963803,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-12T23:30:32.555Z","status":"ssl_error","status_checked_at":"2026-05-12T23:30:18.191Z","response_time":102,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["javascript","programming-language","transpiled-language"],"created_at":"2024-11-10T19:44:11.664Z","updated_at":"2026-05-13T01:31:20.951Z","avatar_url":"https://github.com/OGShawnLee.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Pino\nSimple and aesthetic programming language built with C++ that intends to turn programming a joyful experience.\n\n## Why?\n\nAll the programming languages I've used have something I like and dislike, so I decided to make one that takes the good from all those languages; a language tailored to my taste. I am studying Software Engineering and I thought this project would help me test what I've learnt and become a better programmer by not only doing Web Development but some Systems Programming with a gigachad language such as C++ as well.\n\n## Features\n- [X] Constant and Variable Declaration\n- [X] Function Declaration\n  - [X] Parameter Declaration\n  - [X] Optional Parameter List (no parenthesis)\n  - [X] Parameter List\n    - [X] Optional Commas\n  - [X] Return Statement \n  - [ ] Return Typing\n- [X] Struct Declaration\n  - [X] Attribute Declaration\n  - [X] Method Declaration\n- [X] Enum Declaration\n- [X] Expression\n  - [X] Binary Expression\n    - [X] Enum Member Access\n    - [X] Struct Attribute / Method Access\n    - [ ] Order of Precedence\n    - [ ] Parenthesis\n  - [X] Ternary Expression\n  - [X] Identifier\n  - [X] Literal\n    - [X] Boolean\n    - [X] Float\n    - [X] Integer\n    - [X] String\n      - [X] String Injection\n    - [X] Function Lambda\n      - [X] Parameter Declaration\n      - [X] Optional Parameter List (no parenthesis)\n      - [X] Parameter List (no parenthesis)\n        - [X] Optional Commas\n      - [X] Return Statement\n      - [ ] Return Typing\n  - [X] Function Call\n  - [X] Loop Statement\n    - [X] For In Loop (``for i in \u003citerable\u003e {}``)\n    - [X] For Times Loop (``for i in \u003cinteger\u003e {}``)\n    - [ ] Loop Keywords (continue, break)\n  - [X] Struct Instance\n    - [X] Property Accessing\n    - [ ] Shorthand Syntax \n  - [X] Vector\n    - [X] Initial Elements\n    - [X] Init Block\n- [X] Conditional\n  - [X] If Statement\n    - [X] Else If Statement\n  - [X] Else Statement\n  - [X] Match Statement\n    - [X] When Statement\n      - [X] Multiple Expressions\n    - [X] Default Statement (Else Statement)\n\n## Syntax\n\nThe syntax is heavily inspired by the programming language that has the best one in my opinion, Vlang (and Golang I guess). There are also bits inspired by other languages like Kotlin and Ruby.\n\n### Variables\n\nConstants are declared using the **val** keyword and variables with the **var** keyword. Variables must be assigned a value. (This syntax comes from Kotlin).\n\n```\nvar name = \"Shawn Lee\"\nvar country = \"China\"\nvar children = 0\nvar budget = 12.5 # In terms of money, I have none :yikes:\nvar is_married = false\n\nval planet = \"Earth\"\nval pi = 3.1416\n```\n\n### String Injection\n\nVariables can be easily interpolated inside of strings by writting their name preceded by a **#** character. (This syntax comes from Ruby).\n\n```\nval name = \"Augustus\"\nval empire = \"Roman\"\n\nprintln(\"#name was the first emperor of the #empire Empire\")\n\nval planet = \"Earth\"\nval diameter = 12714\nval message = \"#planet has a diameter of #diameter kilometres\"\n```\n\n### Functions\nFunctions are declared with the **fn** keyword followed by their name and their parameters.\n\n* Parenthesis are optional if the function does not have any parameters.\n* Commas are optional to separate parameters, it is recommeded to add them when the parameters are written in a single line otherwise omit them.\n* When calling a function, commas are optional to separate its arguments.\n\n```\nfn print {\n  println(\"This is a random print, doesn't do much but it's honest work.\")\n}\n\nfn greet(name str, from str) {\n  println(\"Greetings from #from, #name.\")\n}\n\nfn get_message(\n  name str\n  country str\n  budget float\n) {\n  return \"#name lives in #country and has a budget of #budget\"\n}\n\nfn get_screaming_message(message str) {\n  return message:uppercase()\n}\n\nfn double_it(amount int) {\n  return amount * 2\n}\n\nfn get_str(prompt str) {\n  return readline(prompt)\n}\n\nfn get_float(prompt str) {\n  return float(get_str(prompt))\n}\n\nval final_message = get_message(\n  get_str(\"What is your name?\")\n  get_str(\"What country do you live in?\")\n  get_float(\"What is your budget?\")\n)\n\nprintln(\"Message: #final_message\")\n```\n\n### Ternary Expression\n\nSince Pino does not have a ternary operator like C-like languages, the `if` keyword can be used to create what I call a **Ternary Expression**. A ternary expression is declared with the `if` keyword followed by a condition, the `then` keyword followed by an expression and ended with an `else` followed by an expression (`if \u003ccondition\u003e then \u003cexpression\u003e else \u003cexpression\u003e`). \n\n```\nfn get_message(name str, country str, is_married bool) {\n  return if is_married\n    then \"#name lives in #country and is_married\"\n    else \"#name lives in #country and is not married\"\n}\n\nfn max(a int, b int) {\n  return if a \u003e b then a else b\n}\n\nfn min(a int, b int) {\n  return if a \u003c b then a else b\n}\n\nval has_taxes = false\nvar budget = 10\nval amount = if has_taxes then 40 * 0.7 else 40\nval nested = if true\n  then if true \n      then \"Do not\" \n      else \"use\"\n  else \"nested ternary expressions\"\n```\n\n### Function Lambdas\n\nLambdas are anonymous functions that are treated as expressions. They are declared with the **fn** keyword and evidently they don't have a name, and they benefit from the syntax of normal functions: optional commas and parenthesis.\n\n```\nval first_name = \"Shawn\"\nval last_name = \"Lee\"\n\nval get_full_name = fn (first_name str, last_name str) {\n  return \"#first_name #last_name\"\n}\n\nval greet = fn {\n  val full_name = get_full_name(first_name, last_name)\n  println(\"Hello from the creator of Pinolang, #full_name\")\n}\n\nval print_person = fn (\n  first_name str \n  last_name str\n  country str\n) {\n  val full_name = get_full_name(first_name, last_name)\n  println(\"#full_name lives in #country\")\n}\n\ngreet()\nprint_person(\"John\", \"China\", \"China\")\n```\n\n### Structs\n\nStructs are declared with the **struct** keyword followed by their name and their body declaration. Attributes are declared with their name followed by their type.\n\n* Commas are optional to separate attributes. It is recommended to keep them if the struct declaration is written in a single line, otherwise omit them.\n\n```\nstruct Country { name str, continent str }\nstruct Person {\n  name str\n  country Country\n  children int\n  height float\n  is_married bool\n}\n```\n\n### Struct Instances\n\nTo initialise a struct instance declare the name of the struct followed by the definition of its body composed by properties. Properties are defined by their **identifier**, a **colon**, and their **value** which must be an expression (``name: \"Shawn\"``).\n\n* Commas are optional to separate properties, it is recommended to keep them when multiple properties are declared on a single line, otherwise omit them.\n* Accessing an struct instance is done with the member access operator ``:``.\n\n```\nstruct Country { name str, continent str }\nstruct Person {\n  name str\n  country Country # Nested Struct\n  children int\n  height float\n  is_married bool\n  country Country\n}\n\nval person = Person {\n  name: \"Shawn Lee\"\n  country: Country { name: \"China\", \"Asia\" } # Nested Struct Instance\n  children: 0\n  height: 1.74\n  is_married: false\n}\n\nprintln(person:name + \"lives in \" + country:name) # Accesing a Property\n```\n\n### Vectors\n\nA vector is a dynamic array of elements of the same type.\n\n* Use ``[\u003celement-1\u003e, \u003celement-2\u003e, \u003celement-n\u003e]`` for initialising a vector with literal elements, its type will be infered from the first element.\n  * Commas are optional to separate members, it is recommended to keep them when multiple elements are declared on the same line, otherwise omit them.\n* Use ``[]\u003ctype\u003e`` for initialising an empty vector that will be filled with elements of the given type.\n* Use ``[]\u003ctype\u003e { len: \u003cinteger\u003e, init: \u003cexpression\u003e }`` for quickly declaring an array with a given length and filling each index with the result of an expression. Both ``len`` and ``init`` must be declared.\n  * ``len``: is the length of the vector and the number of times the init expression will be evaluated.\n  * ``init``: is an expression that will be called at each index of the vector and its value will be assigned at that position. This expression has access to a context variable called ``it`` that represents the current index. A lambda can be used if multiple stataments are needed for computing a value, or for renaming ``it``.\n\n```\nval countries = [\n  \"Portugal\"\n  \"Spain\"\n  \"France\"\n  \"Italy\"\n  \"England\"\n  \"Scotland\"\n  \"Ireland\"\n]\n\nfor country in countries {\n  println(\"#country is in Europe.\")\n}\n\nval scores = []float\nval integers = []int {\n  len: 30\n  init: it * 1\n}\n\n# '[]int' as a type is not supported yet\nval matrix = [][]int {\n  len: 3\n  init: fn (row int) {\n    return []int {\n      len: 3\n      init: fn (col int) {\n        for {\n          val integer = int(readline(\"Enter a cero or positive integer for position (#row, #col): \"))\n          # Conditional Statements are not supported yet\n          if integer \u003c 0 { \n            println(\"Negative numbers are not allowed, please enter a number number\")\n          }\n          return integer\n        }\n      }\n    }\n  }\n}\n```\n\n### Enums\n\nEnums are declared with the **enum** keyword followed by their name and their members. Members are just identifiers and I recommend following the SCREMING_SNAKE_CASE naming convention... not sure if I should enforce it.\n\n* Commas are optional to separate members, it is recommended to keep them when multiple members are declared on the same line, otherwise omit them.\n* Accessing an enum member value is done with the ``::`` operator.\n\n```\nenum Planet {\n  MERCURY, VENUS, EARTH, MARS\n  JUPITER, SATURN, URANUS, NEPTUNE\n}\n\nval planet = Planet::EARTH\n```\n\n### Loop Statement\n\nLoops can only be declared with the **for** keyword, there is no while nor do keyword.\n\n* Use ``for \u003cit\u003e in \u003citerable\u003e {}`` for iterating over an iterable expression such as a vector or an string.\n* Use ``for \u003cindex\u003e in \u003cinteger\u003e {}`` for executing a set of instructions a certain number of times while keeping a reference to the current iteration index.\n* Use ``for \u003cinteger\u003e {}`` for executing a set of instructions a certain number of times.\n* Use ``for \u003ccondition\u003e {}`` for executing a \"while\" kind of loop. Break out of the loop with keywords (**break, continue, return**).\n* Use ``for {}`` for executing infinite loop, Break out of the loop with keywords.\n \n```\nval characters = [\n  \"Marcus\"\n  \"Dominic\"\n  \"Baird\"\n  \"Cole\"\n]\n\nfor character in characters {\n  println(\"#character is an awesome Gears of War character!\")\n}\n\nfor time in 100 {\n  println(\"This has run for the #time time for a total of 100 times\")\n}\n\nfor 100 {\n  println(\"This will run a hundred times\")\n}\n\nvar is_sleeping = true\nfor is_sleeping {\n  println(\"Pablo is sleeping...\")\n  is_sleeping = false\n}\n\nprintln(\"Pablo is no longer sleeping!\")\n\nfor {\n  println(\"This will run forever!\")\n  break # not really\n}\n```\n\n### Conditional Statements\n\nConditional statements are straightforward and there is not much to say about them, the condition for all of them doesn't require parenthesis.\n\n* `if`: an if statement is declared with the `if` keyword followed by a condition and its block body.\n* `else if`: an else if statement is declared with the keywords `else if` followed by a condition and its block body.\n* `else`: an else statement is declared with the keyword `else` followed by its block body.\n* `match`: a match statement is declared with the `match` keyword followed by a condition and `when` statements or a default `else` branch.\n* `when`: a when statements acts as a branch for a `match` statement, it is declared with the `when` keyword followed by one or multiple expressions.\n\n```\nif true {\n  println(\"This if statement will always run\")\n}\n\nif false {\n  println(\"This if statement will never run\")\n} else {\n  println(\"This else statement will always run\")\n}\n\nval budget = 12.5\n\nif budget \u003e 10000 {\n  println(\"Damn, you a G!\")\n} else if budget \u003e 5000 {\n  println(\"Ight, not bad!\")\n} else if budget \u003e 3000 {\n  println(\"Almost decent, common get you shit together!\")\n} else {\n  println(\"Damn, you a brokie!\")\n}\n\nmatch readline(\"Enter a planet of the solar system to teleport: \")\nwhen \"Earth\" {\n  println(\"You are alive\")\n}\nwhen \"Sun\" {\n  println(\"The sun is not a planet! You dead anyways\")\n}\nelse {\n  println(\"You dead\")\n}\n\nmatch readline(\"Enter a planet of the solar system: \") {\n  when \n  \"Mercury\"\n  \"Venus\"\n  \"Earth\"\n  \"Mars\" {\n    println(\"Rocky Planet\")\n  }\n  when \"Jupiter\", \"Saturn\" {\n    println(\"Gas Giant\")\n  }\n  when \"Uranus\", \"Neptune\" {\n    println(\"Ice Giant\")\n  }\n  when \"Sun\" {\n    println(\"The sun is a star not a planet!\")\n  }\n  else {\n    println(\"Not a planet I know of\")\n  }\n}\n```\n\n\u003c!-- # Pino\n\nSimple and aesthetic programming language built with C++ that intends to turn programming a joyful experience.\n\nAll the programming languages I've used have something I like and dislike, so I decided to make one based on the language I like the most, the V programming language.\nI am studying Software Enginnering and C++ is the language I am being taught, so that is the language used in the project. \nPino is transpiled to JavaScript because it is the language I know the best and I don't know how to compile it to a lower level.\n\nREWRITE: PINO WILL BE REWRITTEN FROM THE GROUND UP BUT THERE WILL NOT BE MANY CHANGES TO THE SYNTAX \n\n## Why Pino?\nEvery cool name I thought of was already used and at that moment I was thinking about **Ergo Proxy**, *my all time favourite anime*. Since **Pino** is a little adorable character from that anime and it is a short name as well... **Pino! Pino! Pino!**\n\n## Comments\n\nMulti Line Comments are not yet supported but the intended syntax is shown right below.\n\n```\n# Single Line Comment\n###\n  Multi\n  Line\n  Comment\n###\n```\n\n## Variables\n\n```\n# Variable\nvar name = \"Shawn Lee\"\n# Constant\nval country = \"China\"\n# Reassignment\nname = \"John China\"\n# To Variable\nvar people = name\n```\n\n## String Injection\n\n```\nval name = \"Shawn Lee\"\nval country = \"China\"\nval budget = 0\nval weight = 64.5\nvar message = \"$name lives in $country, has a budget of $budget and weighs $weight kg\"\n```\n\n## Vectors\n\n```\nfn get_str(it int) {\n  return \"$it: What is going on fella!\"\n}\n\nvar arr_int = []int { len: 6, init: it * 2 }\nvar arr_str = []str { len: 9, init: get_str(it) }\n\nprintln(arr_int, arr_str)\n\nstruct Game {\n  name str\n  characters arr\n}\n\nprintln(Game {\n  name: \"Gears of War\"\n  characters: [\"Marcus\", \"Dominic\", \"Baird\", \"Cole\"]\n})\n\nval game = Game {\n  name: \"Halo\"\n  characters: [\"Master Chief\", \"Cortana\", \"Captain Keyes\", \"Sergeant Johnson\", \"343 Guilty Spark\"]\n}\n\nfn print_game_characters(game Game) {\n  val len = game:characters:length\n  println(\"$game:name Characters $len\")\n  for i in len {\n    val char = game:characters[i]\n    println(\"  Character $i: $char\")\n  }\n}\n\nprint_game_characters(game)\n\nval languages = [\"Vlang\", \"Swift\"]\nval vlang = languages[0]\n\nprintln(\"Languages:\", languages, vlang)\n```\n\n## Functions\n\n```\nfn get_full_name(name str, last_name str) {\n  return \"$name $last_name\"\n}\n\nvar full_name = get_full_name(\"Shawn\", \"Lee\")\n\nprintln(full_name)\n\nfn to_ruble(dollar int) {\n  return dollar * 91\n}\n\nfn to_yen(dollar int) {\n  return dollar * 150\n}\n\nval dollar = 10\nval rubble = to_rubble(dollar)\nval yen = to_yen(dollar)\n\nprintln(\"$dollar dollars are $rubble rubbles and $yen yens\")\n```\n\n## Control Flow\n\n```\nvar has_girlfriend = false\n\nif has_girlfriend {\n  println(\"Shawn Lee has a girlfriend!\")\n} else {\n  println(\"Shawn Lee is still single after all these years!\")\n}\n```\n\n## Loop Statement\n\n```\n# Times Loop\nfor 10 {\n  println(\"This loop has run for 10 times\")\n}\n\n# In Loop\nvar times = 10\nfor i in times {\n  println(\"This has run for the $i time a total of $times\")\n}\n```\n\n## Structs\n\n```\nstruct Phone {\n  brand str\n  name str\n}\n\nstruct Person {\n  full_name str\n  is_married bool\n  budget int\n  phone Phone\n}\n\nfn create_phone(brand str, name str) {\n  return Phone { brand, name }\n  # or Phone { brand name } (commas are optional)\n  # or Phone { brand: brand, name: name } (with no prop shortcut)\n}\n\nval person = Person {\n  full_name: \"Shawn Lee\"\n  is_married: 50 \u003c 10\n  budget: 1000 - 950\n  phone: create_phone(\"Apple\", \"15 Pro Max\")\n}\n\nval name = person:full_name\nval phone_name = person:phone:name\n\nprintln(person)\nprintln(\"$name owns a $phone_name\")\nprintln(\"$person:full_name has a budget of $person:budget $\")\n```\n\n## Functional Programming\n\n```\n# Higher Order Function\nfn get_multiplier_fn(multiplier int) {\n  return fn (num int) {\n    return num * multiplier\n  }\n}\n\nval double_it = get_multiplier_fn(2)\n\nfn times_ten(num int) {\n  return num * 10\n}\n\nfn map(array arr, fun function) {\n  return []any { len: array:length, init: fun(array[it]) }\n}\n\nval arr_int = []int { len: 4, init: times_ten(it) }\nval arr_double = map(arr_int, double_it)\nval arr_triple = map(arr_int, get_multiplier_fn(3))\n\nprintln(\"Array Integers x 1:\", arr_int)\nprintln(\"Array Integers x 2:\", arr_double)\nprintln(\"Array Integers x 3:\", arr_triple)\n\nfn fold(array arr, initial any, fun function) {\n  var acc = initial\n\n  for i in array:length {\n    acc = fun(array[i], acc)\n  }\n\n  return acc\n}\n\nvar total = fold(arr_int, 0, fn (current int, acc int) {\n  return acc + current\n})\n\nprintln(\"Total of [$arr_int] = $total\")\n\n# Assigning a Lambda to a Constant\nval add = fn (a int, b int) {\n  return a + b\n}\n\ntotal = fold(arr_double, 0, add) \nprintln(\"Total of [$arr_double] = $total\")\n\ntotal = fold(arr_triple, 0, add) \nprintln(\"Total of [$arr_double] = $total\")\n```\n\n## Missing Features\n- [X] Binary Expressions\n  - [X] Dual Character Bool Operators (==, !=, \u003e=, \u003c=)\n  - [ ] Order of Precedence (JavaScript handles it once it is transpiled but it is not built in Pino)\n  - [ ] Parenthesis\n- [ ] Checker (Parser output is transpiled without validation)\n- [ ] Comments\n  - [X] Single Line Comment\n  - [ ] Multi Line Comment\n- [ ] Descriptive Parser and Lexer Errors\n- [X] Floats\n- [ ] Functions\n  - [ ] Default Parameter Value\n  - [ ] Function Return Typing\n  - [X] Lambda (Anonymous Function)\n  - [X] Return Statement Vector Initialisation Support\n- [ ] Else If Statement\n- [ ] Match Statement\n- [ ] Modules and Import Statements\n- [X] Strings\n  - [X] Struct Property Access Injection Support (\"$struct:property\")\n- [ ] Structs\n  - [X] Struct Definition\n  - [X] Struct Initialisation\n  - [ ] Struct Operations (delete, read, set)\n  - [X] Struct Type for fn parameters\n  - [X] Optional Commas\n  - [X] Property Shortcut\n- [ ] Vectors\n  - [X] Vector Accesing\n  - [X] Vector Initialisation\n  - [X] Vector Literal ([\"Marcus\", \"Dominic\", \"Baird\", \"Cole\"])\n  - [ ] Vector Operations (pop, prepend, push, shift)\n  - [ ] Vector Type for fn parameters\n- [ ] Yield Statement --\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fogshawnlee%2Fpino-lang","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fogshawnlee%2Fpino-lang","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fogshawnlee%2Fpino-lang/lists"}