Added strawman designs

strawman1.txt

@@ -0,0 +1,54 @@
+# binary_tree takes a comparison function and returns a record (like a JS
+# object) as a module for handling binary trees of values of the same type
+# as compare's arguments.
+def binary_tree(compare) =
+	# Backticks here indicate that leaf is a constructor for a tagged union
+	# (variant) type.
+	let empty = `leaf
+	and insert(tree, value) = when tree is
+		`leaf => `branch({left=`leaf, value = value, right=`leaf),
+		`branch({left, value=value2, right) => when compare(value, value2) is
+			`eq => `branch({left, value, right}),
+			`lt =>
+				let new_left = insert(left, value)
+				in `branch({left=new_left, value=value2, right}),
+			`gt =>
+				let new_right = insert(right, value)
+				in `branch({left, value=value2, new_right})
+	and find(tree, needle) = when tree is
+		`leaf => `nothing,
+		`branch({left, value, right}) => when compare(needle, value) is
+			`eq => `some(value),
+			`lt => find(left, needle),
+			`gt => find(right, needle),
+	and func_we_dont_care_about() = print("ignore me")
+	in {empty, insert, find}
+
+# Prints "`some(2)".
+def do_tree_things() =
+	# Assume that int_compare is in the stdlib or something.
+	# Notice that we can ignore a record field. I want to make record
+	# syntax basically the same as in JS.
+	let {insert, empty, find, ...stuff_we_dont_need} = binary_tree(int_compare)
+	# I invented this fancy partial-application syntax with _, and then found
+	# that Scala does it the same way. Also note the pipe operator from Elm.
+	and _ = empty |> insert(_, 5) |> insert(_, 2) |> insert(_, 10)
+		|> find(2) |> print
+	in stuff_we_dont_need
+
+# Prints "`some(2)\nignore me".
+def main() = do_tree_things().func_we_dont_care_about()
+
+
+# I'd better be able to make type inference work, or else the user might have
+# to annotate binary_tree like this:
+binary_tree : fn('a, 'a) -> Record{
+	empty: recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T},
+	insert: fn(recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T}, 'a) ->
+		recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T},
+	find: fn(recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T}, 'a) ->
+		Union{some of 'a, nothing},
+	func_we_dont_care_about: fn() -> Record{}
+}
+# Though it might be possible to introduce a way to factor out the tree type,
+# which is the big thing starting with "recurse T".

strawman2.txt

@@ -0,0 +1,63 @@
+# v2
+# I realized/remembered that I don't need `def`, `and`, or commas. Because function
+# application isn't by juxtapositon, I can look ahead by one token to know
+# whether the expression is complete.
+# If the language is impure, it also needs a sequencing operator. Let's use ;
+# because why not?
+
+# binary_tree takes a comparison function and returns a record (like a JS
+# object) as a module for handling binary trees of values of the same type
+# as compare's arguments.
+binary_tree(compare) =
+	# Backticks here indicate that leaf is a constructor for a tagged union
+	# (variant) type.
+	let
+		empty = `leaf
+		insert(tree, value) = when tree is
+			`leaf => `branch({left=`leaf, value = value, right=`leaf)
+			`branch({left, value=value2, right) => when compare(value, value2) is
+				`eq => `branch({left, value, right})
+				`lt =>
+					let new_left = insert(left, value)
+					in `branch({left=new_left, value=value2, right})
+				`gt =>
+					let new_right = insert(right, value)
+					in `branch({left, value=value2, new_right})
+		find(tree, needle) = when tree is
+			`leaf => `nothing
+			`branch({left, value, right}) => when compare(needle, value) is
+				`eq => `some(value)
+				`lt => find(left, needle)
+				`gt => find(right, needle)
+		func_we_dont_care_about() = print("ignore me")
+	in {empty, insert, find}
+
+# Prints "`some(2)".
+do_tree_things() =
+	# Assume that int_compare is in the stdlib or something.
+	# Notice that we can ignore a record field. I want to make record
+	# syntax basically the same as in JS.
+	let {insert, empty, find, ...stuff_we_dont_need} = binary_tree(int_compare)
+	# I invented this fancy partial-application syntax with _, and then found
+	# that Scala does it the same way. Also note the pipe operator from Elm.
+	in
+		empty |> insert(_, 5) |> insert(_, 2) |> insert(_, 10)
+			|> find(2) |> print;
+		stuff_we_dont_need
+
+# Prints "`some(2)\nignore me".
+def main() = do_tree_things().func_we_dont_care_about()
+
+
+# I'd better be able to make type inference work, or else the user might have
+# to annotate binary_tree like this:
+binary_tree : fn('a, 'a) -> Record{
+	empty: recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T},
+	insert: fn(recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T}, 'a) ->
+		recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T},
+	find: fn(recurse T in Union{leaf, branch of Record{left: T, value: 'a, right: T}, 'a) ->
+		Union{some of 'a, nothing},
+	func_we_dont_care_about: fn() -> Record{}
+}
+# Though it might be possible to introduce a way to factor out the tree type,
+# which is the big thing starting with "recurse T".

strawman3.txt

@@ -0,0 +1,91 @@
+#v3
+# Added type aliases.
+# Added some row variable examples.
+# Added array type
+
+# TODO Add optional types
+# TODO Get rid of ambiguous syntax at end of type alias definition.
+# TODO Try out arbitrary strings as field names
+	# This should be fine without any extra syntax, as long as we don't allow pattern-matching primitive values.
+	# For consistency, especially re: punning, we'd need to also allow this for normal identifiers, which would need
+	# new syntax.
+# TODO Modules (files) and opaque types
+# TODO More primitive types
+
+# v2
+# I realized/remembered that I don't need `def`, `and`, or commas. Because function
+# application isn't by juxtapositon, I can look ahead by one token to know
+# whether the expression is complete.
+# If the language is impure, it also needs a sequencing operator. Let's use ;
+# because why not?
+
+
+type alias tree 'a = recurse 'T in <leaf, branch: {left: 'T, value: 'a, right: 'T}>
+type alias maybe 'a = <some: 'a, nothing>
+type alias unit = {}
+binary_tree : fn('a, 'a) -> {
+	empty: tree 'a,
+	insert: fn(tree 'a, 'a) -> tree 'a,
+	find: fn(tree 'a, 'a) -> maybe 'a,
+	func_we_dont_care_about: fn() -> unit
+}
+
+# Type aliases should appear in compiler messages.
+# binary_tree takes a comparison function and returns a record (like a JS
+# object) as a module for handling binary trees of values of the same type
+# as compare's arguments.
+binary_tree(compare) =
+	# Backticks here indicate that leaf is a constructor for a tagged union
+	# (variant) type.
+	let
+		# A let expression can bind multiple names. Functions have access to all names within the expression,
+		# while other values only have access to names bound before them.
+		# This is to prevent nonsensical mutual recursion between non-function values.
+		empty = `leaf
+		insert(tree, value) = when tree is
+			`leaf => `branch({left=`leaf, value = value, right=`leaf)
+			`branch({left, value=value2, right}) => when compare(value, value2) is
+				`eq => `branch({left, value, right})
+				`lt =>
+					let new_left = insert(left, value)
+					in `branch({left=new_left, value=value2, right})
+				`gt =>
+					let new_right = insert(right, value)
+					in `branch({left, value=value2, new_right})
+		find(tree, needle) = when tree is
+			`leaf => `nothing
+			`branch({left, value, right}) => when compare(needle, value) is
+				`eq => `some(value)
+				`lt => find(left, needle)
+				`gt => find(right, needle)
+		func_we_dont_care_about() = print("ignore me")
+	in {empty, insert, find}
+
+# Prints "`some(2)".
+do_tree_things() =
+	# Assume that int_compare is in the stdlib or something.
+	# Notice that we can ignore a record field. I want to make record
+	# syntax basically the same as in JS.
+	let {insert, empty, find | stuff_we_dont_need} = binary_tree(int_compare)
+	# I invented this fancy partial-application syntax with _, and then found
+	# that Scala does it the same way. Also note the pipe operator from Elm.
+	in
+		empty |> insert(_, 5) |> insert(_, 2) |> insert(_, 10)
+			|> find(2) |> print;
+		stuff_we_dont_need
+
+# Prints "`some(2)\nignore me".
+main() = do_tree_things().func_we_dont_care_about()
+
+annotate: fn('a, {|'b}) -> {note: 'a | 'b}
+annotate(note, obj) = { note | obj }
+
+deannotate: fn({note: 'a | 'b}) -> {|'b}
+deannotate(r) = let {note=_ | rest} = r in rest
+
+reannotate: fn('a, {note: 'a | 'b}) -> {note: 'a | 'b}
+reannotate(note, obj) = {|obj with note=note} # or maybe field punning: {|obj with note}
+
+map: fn(fn('a) -> 'b, ['a]) -> ['b]
+
+doubled = let double(n) = 2 * n in map(double, [1,2,3,4,5])

strawman4.txt

@@ -0,0 +1,90 @@
+# v4
+# Moved type annotations into bindings.
+# Added def keyword for top-level bindings.
+# Added and keyword to multiple-binding let-expressions.
+
+# v3
+# Added type aliases.
+# Added some row variable examples.
+# Added array type
+
+# TODO Add optional types
+# TODO Get rid of ambiguous syntax at end of type alias definition.
+# TODO Try out arbitrary strings as field names
+	# This should be fine without any extra syntax, as long as we don't allow pattern-matching primitive values.
+	# For consistency, especially re: punning, we'd need to also allow this for normal identifiers, which would need
+	# new syntax.
+# TODO Modules (files) and opaque types
+# TODO More primitive types
+
+# v2
+# I realized/remembered that I don't need `def`, `and`, or commas. Because function
+# application isn't by juxtapositon, I can look ahead by one token to know
+# whether the expression is complete.
+# If the language is impure, it also needs a sequencing operator. Let's use ;
+# because why not?
+
+
+type alias tree 'a = recurse 'T in <leaf, branch: {left: 'T, value: 'a, right: 'T}>
+type alias maybe 'a = <some: 'a, nothing>
+type alias unit = {}
+
+# Type aliases should appear in compiler messages.
+# binary_tree takes a comparison function and returns a record (like a JS
+# object) as a module for handling binary trees of values of the same type
+# as compare's arguments.
+def binary_tree(compare: fn('a) -> 'a) -> {
+	empty: tree 'a,
+	insert: fn(tree 'a, 'a) -> tree 'a,
+	find: fn(tree 'a, 'a) -> maybe 'a,
+	func_we_dont_care_about: fn() -> unit
+} =
+	# A let expression can bind multiple names. Functions have access to all names within the expression,
+	# while other values only have access to names bound before them.
+	# This is to prevent nonsensical mutual recursion between non-function values.
+	# Backticks here indicate that leaf is a constructor for a tagged union (variant) type.
+	let empty = `leaf
+	and insert(tree, value) = when tree is
+			`leaf => `branch({left=`leaf, value = value, right=`leaf)
+			`branch({left, value=value2, right}) => when compare(value, value2) is
+				`eq => `branch({left, value, right})
+				`lt =>
+					let new_left = insert(left, value)
+					in `branch({left=new_left, value=value2, right})
+				`gt =>
+					let new_right = insert(right, value)
+					in `branch({left, value=value2, new_right})
+	and find(tree, needle) = when tree is
+			`leaf => `nothing
+			`branch({left, value, right}) => when compare(needle, value) is
+				`eq => `some(value)
+				`lt => find(left, needle)
+				`gt => find(right, needle)
+	and func_we_dont_care_about() = print("ignore me")
+	in {empty, insert, find, func_we_dont_care_about}
+
+# Prints "`some(2)".
+def do_tree_things() =
+	# Assume that int_compare is in the stdlib or something.
+	let {insert, empty, find | stuff_we_dont_need} = binary_tree(int_compare)
+	# I invented this fancy partial-application syntax with _, and then found
+	# that Scala does it the same way. Also note the pipe operator from Elm.
+	in
+		empty |> insert(_, 5) |> insert(_, 2) |> insert(_, 10)
+			|> find(2) |> print;
+		stuff_we_dont_need
+
+# Prints "`some(2)\nignore me".
+def main() = do_tree_things().func_we_dont_care_about()
+
+def annotate(note: 'a, obj: {|'b}) -> {note: 'a | 'b} =
+	{ note | obj }
+
+def deannotate(r: {note: 'a | 'b}) -> {|'b} = let {note=_ | rest} = r in rest
+
+def reannotate(note: 'a, obj: {note: 'a | 'b}) -> {note: 'a | 'b} =
+	{|obj with note=note} # or maybe field punning: {|obj with note}
+
+def map(f: fn('a) -> 'b, xs: ['a]) -> ['b] = crash("TODO")
+
+def doubled = let double(n) = 2 * n in map(double, [1,2,3,4,5])