From 8c3aa951396b5111d693b86daecdbbcacf95909a Mon Sep 17 00:00:00 2001 From: Markus Westerlind Date: Sat, 14 Oct 2017 00:35:17 +0200 Subject: [PATCH] feat: Add a trailing comman on records that take multiple lines --- Cargo.toml | 3 +- format/Cargo.toml | 4 +- format/src/pretty_print.rs | 26 +++++-- format/tests/pretty_print.rs | 14 +++- repl/Cargo.toml | 1 + repl/src/repl.glu | 10 +-- repl/src/repl.rs | 1 + src/lib.rs | 1 - std/bool.glu | 10 +-- std/char.glu | 2 +- std/float.glu | 12 ++-- std/int.glu | 10 +-- std/io.glu | 2 +- std/list.glu | 10 +-- std/map.glu | 2 +- std/option.glu | 30 ++++---- std/parser.glu | 129 +++++++++++++++++------------------ std/prelude.glu | 16 ++--- std/result.glu | 16 ++--- std/stream.glu | 2 +- std/unit.glu | 2 +- std/writer.glu | 4 +- 22 files changed, 163 insertions(+), 144 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index babd9d6fd2..d0c69ead06 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,7 +26,6 @@ gluon_base = { path = "base", version = "0.6.1" } # GLUON gluon_check = { path = "check", version = "0.6.1" } # GLUON gluon_parser = { path = "parser", version = "0.6.1" } # GLUON gluon_vm = { path = "vm", version = "0.6.1" } # GLUON -gluon_format = { path = "format", version = "0.6.0" } #GLUON log = "0.3.6" quick-error = "1.0.0" @@ -68,7 +67,7 @@ gluon_completion = { path = "completion", version = "0.6.1" } # GLUON default = ["regex"] serialization = ["serde", "serde_state", "serde_derive_state", "gluon_vm/serialization"] -test = ["serialization", "gluon_vm/test", "gluon_check/test", "gluon_parser/test", "gluon_format/test"] +test = ["serialization", "gluon_vm/test", "gluon_check/test", "gluon_parser/test"] nightly = ["compiletest_rs"] diff --git a/format/Cargo.toml b/format/Cargo.toml index ef36ae4bce..4ddd9ba88e 100644 --- a/format/Cargo.toml +++ b/format/Cargo.toml @@ -11,7 +11,6 @@ repository = "https://github.com/gluon-lang/gluon" documentation = "https://docs.rs/gluon" [dependencies] -env_logger = { version = "0.3.4", optional = true } log = "0.3.6" pretty = "0.3.2" itertools = "0.5.6" @@ -20,8 +19,9 @@ gluon_base = { path = "../base", version = "0.6.1" } # GLUON gluon_parser = { path = "../parser", version = "0.6.1" } # GLUON [dev-dependencies] +env_logger = "0.3.4" difference = "1.0" pretty_assertions = "0.3.0" [features] -test = ["env_logger"] +test = [] diff --git a/format/src/pretty_print.rs b/format/src/pretty_print.rs index d42d8da418..9e9f3a1ee4 100644 --- a/format/src/pretty_print.rs +++ b/format/src/pretty_print.rs @@ -416,13 +416,27 @@ impl<'a: 'e, 'e> Printer<'a, 'e> { }), |spanned| spanned.value, )) + .append( + if (!exprs.is_empty() || !types.is_empty()) && line.1 == arena.newline().1 { + arena.text(",") + } else { + arena.nil() + }, + ) .append(match *base { - Some(ref base) => chain![arena; - self.space_after(last_field_end), - "..", - self.space_before(base.span.start), - self.pretty_expr_(base.span.start, base) - ], + Some(ref base) => { + let comments = self.comments_after(last_field_end); + chain![arena; + if comments.1 == arena.nil().1 { + line.clone() + } else { + comments + }, + "..", + self.space_before(base.span.start), + self.pretty_expr_(base.span.start, base) + ] + } None => arena.nil(), }) .nest(INDENT) diff --git a/format/tests/pretty_print.rs b/format/tests/pretty_print.rs index b6faf07fb8..b72abeaead 100644 --- a/format/tests/pretty_print.rs +++ b/format/tests/pretty_print.rs @@ -27,7 +27,12 @@ fn test_format(name: &str) { let out_str = format_expr(&contents).unwrap(); if contents != out_str { - let out_path = Path::new(&env::var("OUT_DIR").unwrap()).join(name.file_name().unwrap()); + let args: Vec<_> = env::args().collect(); + let out_path = Path::new(&args[0][..]) + .parent() + .and_then(|p| p.parent()) + .expect("folder") + .join(name.file_name().unwrap()); File::create(out_path) .unwrap() .write_all(out_str.as_bytes()) @@ -102,6 +107,11 @@ fn writer() { test_format("std/writer.glu"); } +#[test] +fn parser() { + test_format("std/parser.glu"); +} + #[test] fn repl() { test_format("repl/src/repl.glu"); @@ -152,7 +162,7 @@ fn preserve_whitespace_in_record() { aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaax = 1, - bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbby = 2 + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbby = 2, } "#; assert_diff!(&format_expr(expr).unwrap(), expr, " ", 0); diff --git a/repl/Cargo.toml b/repl/Cargo.toml index 0280b07625..2e683d8579 100644 --- a/repl/Cargo.toml +++ b/repl/Cargo.toml @@ -27,6 +27,7 @@ log = "0.3.6" env_logger = { version = "0.3.4", optional = true } lazy_static = "0.2.0" rustyline = "1.0.0" +walkdir = "1" [dev-dependencies] pretty_assertions = "0.3.4" diff --git a/repl/src/repl.glu b/repl/src/repl.glu index 758602beca..c1b7071af4 100644 --- a/repl/src/repl.glu +++ b/repl/src/repl.glu @@ -43,19 +43,19 @@ let commands : Map String Cmd = let cmds = singleton "q" { info = "Quit the REPL", action = \_ -> wrap False } <> singleton "t" { info = "Prints the type with an expression", - action = \arg -> repl_prim.type_of_expr arg >>= print_result *> wrap True + action = \arg -> repl_prim.type_of_expr arg >>= print_result *> wrap True, } <> singleton "i" { info = "Prints information about the given name", - action = \arg -> repl_prim.find_info arg >>= print_result *> wrap True + action = \arg -> repl_prim.find_info arg >>= print_result *> wrap True, } <> singleton "k" { info = "Prints the kind with the given type", - action = \arg -> repl_prim.find_kind arg >>= print_result *> wrap True + action = \arg -> repl_prim.find_kind arg >>= print_result *> wrap True, } <> singleton "l" { info = "Loads the file at \'folder/module.ext\' and stores it at \'module\'", - action = \arg -> load_file arg >>= io.println *> wrap True + action = \arg -> load_file arg >>= io.println *> wrap True, } <> singleton "h" { info = "Print this help", @@ -65,7 +65,7 @@ let commands : Map String Cmd = io.println (" :" ++ cmd.key ++ " " ++ cmd.value.info) print_header *> for (load commands) print_cmd - *> wrap True + *> wrap True, } commands <- cmds load commands diff --git a/repl/src/repl.rs b/repl/src/repl.rs index 6fa2ea5866..25c37da9fa 100644 --- a/repl/src/repl.rs +++ b/repl/src/repl.rs @@ -10,6 +10,7 @@ use futures::Future; use self::rustyline::error::ReadlineError; + use base::ast::{Expr, Pattern, SpannedPattern, Typed}; use base::error::InFile; use base::kind::Kind; diff --git a/src/lib.rs b/src/lib.rs index c7b76b35a3..cc7cd8e4d1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -24,7 +24,6 @@ extern crate serde_state as serde; pub extern crate gluon_base as base; pub extern crate gluon_check as check; -pub extern crate gluon_format as format; pub extern crate gluon_parser as parser; #[macro_use] pub extern crate gluon_vm as vm; diff --git a/std/bool.glu b/std/bool.glu index 973c7d18b8..c0b7c96a68 100644 --- a/std/bool.glu +++ b/std/bool.glu @@ -16,7 +16,7 @@ let conjunctive = let monoid : Monoid Bool = { semigroup = semigroup, - empty = True + empty = True, } { semigroup, monoid } @@ -28,7 +28,7 @@ let disjunctive = let monoid : Monoid Bool = { semigroup = semigroup, - empty = False + empty = False, } { semigroup, monoid } @@ -38,12 +38,12 @@ let exclusive = let monoid : Monoid Bool = { semigroup = semigroup, - empty = False + empty = False, } let group : Group Bool = { monoid = monoid, - inverse = id + inverse = id, } { semigroup, monoid, group } @@ -69,5 +69,5 @@ let show : Show Bool = { exclusive, eq, ord, - show + show, } diff --git a/std/char.glu b/std/char.glu index 3abf433bdc..75c509de1c 100644 --- a/std/char.glu +++ b/std/char.glu @@ -4,7 +4,7 @@ let eq : Eq Char = { (==) = \l r -> l #Char== r } let ord : Ord Char = { eq = eq, - compare = \l r -> if l #Char< r then LT else if l #Char== r then EQ else GT + compare = \l r -> if l #Char< r then LT else if l #Char== r then EQ else GT, } let show : Show Char = { show = prim.show_char } diff --git a/std/float.glu b/std/float.glu index b1584e8e7a..3b3f5dc337 100644 --- a/std/float.glu +++ b/std/float.glu @@ -7,12 +7,12 @@ let additive = let monoid : Monoid Float = { semigroup = semigroup, - empty = 0.0 + empty = 0.0, } let group : Group Float = { monoid = monoid, - inverse = \x -> 0.0 #Float- x + inverse = \x -> 0.0 #Float- x, } { semigroup, monoid, group } @@ -22,12 +22,12 @@ let multiplicative = let monoid : Monoid Float = { semigroup = semigroup, - empty = 1.0 + empty = 1.0, } let group : Group Float = { monoid = monoid, - inverse = \x -> 1.0 #Float/ x + inverse = \x -> 1.0 #Float/ x, } { semigroup, monoid, group } @@ -38,7 +38,7 @@ let eq : Eq Float = { let ord : Ord Float = { eq = eq, - compare = \l r -> if l #Float< r then LT else if l #Float== r then EQ else GT + compare = \l r -> if l #Float< r then LT else if l #Float== r then EQ else GT, } let num : Num Float = { @@ -47,7 +47,7 @@ let num : Num Float = { (-) = \l r -> l #Float- r, (*) = multiplicative.semigroup.append, (/) = \l r -> l #Float/ r, - negate = additive.group.inverse + negate = additive.group.inverse, } let show : Show Float = { diff --git a/std/int.glu b/std/int.glu index e76701d2ed..a79a32dbc6 100644 --- a/std/int.glu +++ b/std/int.glu @@ -9,12 +9,12 @@ let additive = let monoid : Monoid Int = { semigroup = semigroup, - empty = 0 + empty = 0, } let group : Group Int = { monoid = monoid, - inverse = \x -> 0 #Int- x + inverse = \x -> 0 #Int- x, } { semigroup, monoid, group } @@ -26,7 +26,7 @@ let multiplicative = let monoid : Monoid Int = { semigroup = semigroup, - empty = 1 + empty = 1, } { semigroup, monoid } @@ -37,7 +37,7 @@ let eq = { let ord = { eq = eq, - compare = \l r -> if l #Int< r then LT else if l #Int== r then EQ else GT + compare = \l r -> if l #Int< r then LT else if l #Int== r then EQ else GT, } let num = { @@ -46,7 +46,7 @@ let num = { (-) = \l r -> l #Int- r, (*) = multiplicative.semigroup.append, (/) = \l r -> l #Int/ r, - negate = additive.group.inverse + negate = additive.group.inverse, } let show : Show Int = { diff --git a/std/io.glu b/std/io.glu index f731d8f791..5bcc173965 100644 --- a/std/io.glu +++ b/std/io.glu @@ -12,7 +12,7 @@ let applicative : Applicative IO = let monad : Monad IO = { applicative = applicative, - flat_map = io_flat_map + flat_map = io_flat_map, } { diff --git a/std/list.glu b/std/list.glu index f244c27753..4bac8f94fc 100644 --- a/std/list.glu +++ b/std/list.glu @@ -32,7 +32,7 @@ let semigroup : Semigroup (List a) = let monoid : Monoid (List a) = { semigroup = semigroup, - empty = Nil + empty = Nil, } let eq a : Eq a -> Eq (List a) = @@ -81,7 +81,7 @@ let some alternative x : Alternative f -> f a -> f (List a) = let alternative : Alternative List = { applicative = applicative, or = semigroup.append, - empty = Nil + empty = Nil, } let monad : Monad List = @@ -107,7 +107,7 @@ let show : Show a -> Show (List a) = \d -> | Nil -> d.show y | Nil -> "" - "[" ++ show_elems xs ++ "]" + "[" ++ show_elems xs ++ "]", } let foldable : Foldable List = @@ -129,7 +129,7 @@ let traversable : Traversable List = { traverse = \app f -> foldable.foldr (\a b -> app.apply (app.functor.map Cons (f a)) b) - (app.wrap Nil) + (app.wrap Nil), } { @@ -146,5 +146,5 @@ let traversable : Traversable List = { monad, show, foldable, - traversable + traversable, } diff --git a/std/map.glu b/std/map.glu index 257db1fbf3..c3daac0da3 100644 --- a/std/map.glu +++ b/std/map.glu @@ -106,7 +106,7 @@ and make ord : Ord k -> _ = traverse_with_key, to_list, keys, - values + values, } { Map, make } diff --git a/std/option.glu b/std/option.glu index 7d1fb067f9..60ce2982b7 100644 --- a/std/option.glu +++ b/std/option.glu @@ -14,12 +14,12 @@ let former = append = \l r -> match l with | Some x -> Some x - | None -> r + | None -> r, } let monoid : Monoid (Option a) = { semigroup = semigroup, - empty = None + empty = None, } { semigroup, monoid } @@ -29,12 +29,12 @@ let latter = append = \l r -> match r with | Some x -> Some x - | None -> l + | None -> l, } let monoid : Monoid (Option a) = { semigroup = semigroup, - empty = None + empty = None, } { semigroup, monoid } @@ -45,12 +45,12 @@ let semigroup a : Semigroup a -> Semigroup (Option a) = { | (Some x, Some y) -> Some (a.append x y) | (Some _, None) -> l | (None, Some _) -> r - | (None, None) -> None + | (None, None) -> None, } let monoid a : Semigroup a -> Monoid (Option a) = { semigroup = semigroup a, - empty = None + empty = None, } let eq a : Eq a -> Eq (Option a) = { @@ -58,7 +58,7 @@ let eq a : Eq a -> Eq (Option a) = { match (l, r) with | (Some l_val, Some r_val) -> a.(==) l_val r_val | (None, None) -> True - | _ -> False + | _ -> False, } let ord a : Ord a -> Ord (Option a) = { @@ -68,14 +68,14 @@ let ord a : Ord a -> Ord (Option a) = { | (Some l_val, Some r_val) -> a.compare l_val r_val | (None, Some _) -> LT | (Some _, None) -> GT - | (None, None) -> EQ + | (None, None) -> EQ, } let functor : Functor Option = { map = \f x -> match x with | Some y -> Some (f y) - | None -> None + | None -> None, } let applicative : Applicative Option = { @@ -84,7 +84,7 @@ let applicative : Applicative Option = { match (f, x) with | (Some g, Some y) -> Some (g y) | _ -> None, - wrap = \x -> Some x + wrap = \x -> Some x, } let alternative : Alternative Option = { @@ -93,7 +93,7 @@ let alternative : Alternative Option = { match x with | Some _ -> x | None -> y, - empty = None + empty = None, } let monad : Monad Option = { @@ -101,7 +101,7 @@ let monad : Monad Option = { flat_map = \f m -> match m with | Some x -> f x - | None -> None + | None -> None, } let show : Show a -> Show (Option a) = \d -> @@ -122,7 +122,7 @@ let foldable : Foldable Option = { foldl = \f z o -> match o with | None -> z - | Some x -> f z x + | Some x -> f z x, } let traversable : Traversable Option = { @@ -131,7 +131,7 @@ let traversable : Traversable Option = { traverse = \app f o -> match o with | None -> app.wrap None - | Some x -> app.functor.map Some (f x) + | Some x -> app.functor.map Some (f x), } { @@ -149,5 +149,5 @@ let traversable : Traversable Option = { monad, show, foldable, - traversable + traversable, } diff --git a/std/parser.glu b/std/parser.glu index 8bb260f2cd..80506583a6 100644 --- a/std/parser.glu +++ b/std/parser.glu @@ -10,21 +10,21 @@ let list = import! "std/list.glu" let { List } = list let { Option } = import! "std/option.glu" -type OffsetString = { start: Int, end: Int, buffer: String } +type OffsetString = { start : Int, end : Int, buffer : String } type Position = Int type Error = String -type ParseResult a = Result Error { value: a, buffer: OffsetString } +type ParseResult a = Result Error { value : a, buffer : OffsetString } type Parser a = - OffsetString -> ParseResult a + OffsetString -> ParseResult a -let parser: Parser a -> Parser a = id +let parser : Parser a -> Parser a = id let functor : Functor Parser = { map = \f m -> parser (\buffer -> - let result = parser m buffer - match result with - | Ok a -> Ok { value = f a.value, buffer = a.buffer } - | Err err -> Err err) + let result = parser m buffer + match result with + | Ok a -> Ok { value = f a.value, buffer = a.buffer } + | Err err -> Err err) } let { map } = functor @@ -33,28 +33,28 @@ let applicative : Applicative Parser = { functor, apply = \f m -> parser (\buffer -> - let result1 = parser f buffer - match result1 with - | Ok g -> - let result2 = parser m g.buffer - match result2 with - | Ok a -> Ok { value = g.value a.value, buffer = a.buffer } - | Err err -> Err err - | Err err -> Err err), - - wrap = \value -> parser (\buffer -> Ok { value, buffer }) + let result1 = parser f buffer + match result1 with + | Ok g -> + let result2 = parser m g.buffer + match result2 with + | Ok a -> Ok { value = g.value a.value, buffer = a.buffer } + | Err err -> Err err + | Err err -> Err err), + + wrap = \value -> parser (\buffer -> Ok { value, buffer }), } let { (*>), (<*), wrap } = prelude.make_Applicative applicative -let alternative: Alternative Parser = { +let alternative : Alternative Parser = { applicative, or = \l r -> parser (\stream -> - match parser l stream with - | Ok a -> Ok a - | Err _ -> parser r stream), - empty = parser (\stream -> Err "empty") + match parser l stream with + | Ok a -> Ok a + | Err _ -> parser r stream), + empty = parser (\stream -> Err "empty"), } let { (<|>) } = prelude.make_Alternative alternative @@ -63,32 +63,32 @@ let monad : Monad Parser = { applicative, flat_map = \f m -> parser (\buffer -> - match parser m buffer with - | Ok a -> parser (f a.value) a.buffer - | Err err -> Err err) + match parser m buffer with + | Ok a -> parser (f a.value) a.buffer + | Err err -> Err err), } let { (>>=), flat_map } = prelude.make_Monad monad -let uncons stream : OffsetString -> Option { char: Char, rest: OffsetString } = +let uncons stream : OffsetString -> Option { char : Char, rest : OffsetString } = if stream.start == stream.end then None else let c = string.char_at stream.buffer stream.start let char_len = char.len_utf8 c Some { - char = c, - rest = { - start = stream.start + char_len, - end = stream.end, - buffer = stream.buffer, + char = c, + rest = { + start = stream.start + char_len, + end = stream.end, + buffer = stream.buffer, + }, } - } -let update_position c position: Char -> Position -> Position = +let update_position c position : Char -> Position -> Position = position + char.len_utf8 c -let any: Parser Char = +let any : Parser Char = parser (\stream -> match uncons stream with | Some record -> @@ -96,18 +96,17 @@ let any: Parser Char = Ok { value = char, buffer = rest } | None -> Err "End of stream") -let fail message: String -> Parser a = +let fail message : String -> Parser a = parser (\stream -> Err message) -let satisfy predicate: (Char -> Bool) -> Parser Char = +let satisfy predicate : (Char -> Bool) -> Parser Char = let f c = - if predicate c then - wrap c - else - fail ("Unexpected character " <> char.show.show c) + if predicate c + then wrap c + else fail ("Unexpected character " <> char.show.show c) flat_map f any -let token expected: Char -> Parser Char = +let token expected : Char -> Parser Char = satisfy (\c -> expected == c) let take1 predicate : (Char -> Bool) -> Parser String = @@ -115,21 +114,17 @@ let take1 predicate : (Char -> Bool) -> Parser String = let take_ stream2 = match uncons stream2 with | Some record -> - if predicate record.char then - take_ record.rest - else if stream.start == stream2.start then - Err "Unexpected token" - else - Ok { - value = string.slice stream.buffer stream.start stream2.start, - buffer = stream2 - } + if predicate record.char + then take_ record.rest + else if stream.start == stream2.start then Err "Unexpected token" else Ok { + value = string.slice stream.buffer stream.start stream2.start, + buffer = stream2, + } | None -> Ok { - value = string.slice stream.buffer stream.start stream.end, - buffer = stream2 - } - take_ stream - ) + value = string.slice stream.buffer stream.start stream.end, + buffer = stream2, + } + take_ stream) let take predicate : (Char -> Bool) -> Parser String = take1 predicate <|> wrap "" @@ -139,9 +134,9 @@ let take_string p : Parser a -> Parser String = match parser p stream with | Ok a -> Ok { - value = string.slice stream.buffer stream.start a.buffer.start, - buffer = a.buffer - } + value = string.slice stream.buffer stream.start a.buffer.start, + buffer = a.buffer, + } | Err err -> Err err) let spaces = take char.is_whitespace @@ -149,7 +144,7 @@ let spaces = take char.is_whitespace let lazy_parser f : (() -> Parser a) -> Parser a = parser (\stream -> f () stream) -let between l r x: Parser a -> Parser b -> Parser c -> Parser c = +let between l r x : Parser a -> Parser b -> Parser c -> Parser c = l *> x <* r let many p : Parser a -> Parser (List a) = @@ -171,13 +166,13 @@ let one_of s : String -> Parser Char = False else let c = string.char_at s i - if first == c then - True - else - one_of_ (i + char.len_utf8 c) - one_of_ 0) <|> fail ("Expected one of `" <> s <> "`") + if first == c + then True + else one_of_ (i + char.len_utf8 c) + one_of_ 0) + <|> fail ("Expected one of `" <> s <> "`") -let parse p input: Parser a -> String -> Result String a = +let parse p input : Parser a -> String -> Result String a = match p { start = 0, end = string.len input, buffer = input } with | Ok ok -> Ok ok.value | Err err -> Err err @@ -192,5 +187,5 @@ let parse p input: Parser a -> String -> Result String a = any, between, token, many, many1, satisfy, spaces, take1, lazy_parser, fail, take_string, skip_many, skip_many1, one_of, - parse + parse, } diff --git a/std/prelude.glu b/std/prelude.glu index 21e659946b..a1f9ffcd74 100644 --- a/std/prelude.glu +++ b/std/prelude.glu @@ -28,7 +28,7 @@ let semigroup_Ordering : Semigroup Ordering = { append = \x y -> match x with | EQ -> y - | _ -> x + | _ -> x, } /// `Monoid a` represents an semigroup an which has an identity. This means @@ -46,12 +46,12 @@ type Monoid a = { let monoid_Function monoid : Monoid b -> Monoid (a -> b) = { semigroup = semigroup_Function monoid.semigroup, - empty = \_ -> monoid.empty + empty = \_ -> monoid.empty, } let monoid_Ordering : Monoid Ordering = { semigroup = semigroup_Ordering, - empty = EQ + empty = EQ, } /// `Group a` represents an monoid an which has an inverse element. This means @@ -125,7 +125,7 @@ let make_Category category : Category cat -> _ = let category_Function : Category (->) = { id = \x -> x, - compose = \f g x -> f (g x) + compose = \f g x -> f (g x), } /// The identity function, where `id x == x` @@ -214,7 +214,7 @@ let make_Applicative applicative = let applicative_Function : Applicative ((->) a) = { functor = functor_Function, apply = \f g x -> f x (g x), - wrap = const + wrap = const, } type Alternative f = { applicative : Applicative f, or : f a -> f a -> f a, empty : f a } @@ -272,7 +272,7 @@ let make_Monad monad : Monad m -> _ = let monad_Function : Monad ((->) a) = { applicative = applicative_Function, - flat_map = \f m x -> f (m x) x + flat_map = \f m x -> f (m x) x, } /// `Show a` represents a conversion function from `a` to a readable string. @@ -334,7 +334,7 @@ let make_Foldable foldable : Foldable t -> _ = all, any, elem, - count + count, } type Traversable t = { @@ -402,5 +402,5 @@ let make_Traversable traversable : Traversable t -> _ = (<<), (>>), - Show + Show, } diff --git a/std/result.glu b/std/result.glu index 9a810c7c28..61f8d898d1 100644 --- a/std/result.glu +++ b/std/result.glu @@ -19,7 +19,7 @@ let eq e a : Eq e -> Eq a -> Eq (Result e a) = { match (l, r) with | (Ok l_val, Ok r_val) -> a.(==) l_val r_val | (Err l_val, Err r_val) -> e.(==) l_val r_val - | _ -> False + | _ -> False, } let ord e a : Ord e -> Ord a -> Ord (Result e a) = { @@ -29,14 +29,14 @@ let ord e a : Ord e -> Ord a -> Ord (Result e a) = { | (Ok l_val, Ok r_val) -> a.compare l_val r_val | (Err l_val, Err r_val) -> e.compare l_val r_val | (Ok _, Err _) -> LT - | (Err _, Ok _) -> GT + | (Err _, Ok _) -> GT, } let functor : Functor (Result e) = { map = \f x -> match x with | Ok y -> Ok (f y) - | Err _ -> x + | Err _ -> x, } let applicative : Applicative (Result e) = { @@ -46,7 +46,7 @@ let applicative : Applicative (Result e) = { | (Ok g, Ok y) -> Ok (g y) | (Ok _, Err _) -> x | (Err x, _) -> Err x, - wrap = \x -> Ok x + wrap = \x -> Ok x, } let monad : Monad (Result e) = { @@ -54,7 +54,7 @@ let monad : Monad (Result e) = { flat_map = \f m -> match m with | Ok x -> f x - | Err err -> Err err + | Err err -> Err err, } let foldable : Foldable (Result e) = { @@ -65,7 +65,7 @@ let foldable : Foldable (Result e) = { foldl = \f z r -> match r with | Err _ -> z - | Ok x -> f z x + | Ok x -> f z x, } let traversable : Traversable (Result e) = { @@ -74,7 +74,7 @@ let traversable : Traversable (Result e) = { traverse = \app f r -> match r with | Err e -> app.wrap (Err e) - | Ok x -> app.functor.map Ok (f x) + | Ok x -> app.functor.map Ok (f x), } let show : Show e -> Show t -> Show (Result e t) = \e t -> @@ -98,5 +98,5 @@ let show : Show e -> Show t -> Show (Result e t) = \e t -> monad, foldable, traversable, - show + show, } diff --git a/std/stream.glu b/std/stream.glu index 898c4bd871..cbf96e726a 100644 --- a/std/stream.glu +++ b/std/stream.glu @@ -61,5 +61,5 @@ let functor : Functor Stream = fold, to_list, zip_with, - functor + functor, } diff --git a/std/unit.glu b/std/unit.glu index 0cd3d4a517..6e4e85ef50 100644 --- a/std/unit.glu +++ b/std/unit.glu @@ -10,5 +10,5 @@ let show : Show () = { show = const "()" } { eq, ord, - show + show, } diff --git a/std/writer.glu b/std/writer.glu index 669f633a45..2b587a157b 100644 --- a/std/writer.glu +++ b/std/writer.glu @@ -17,14 +17,14 @@ let make monoid : Monoid w -> Impl w = let applicative : Applicative (Writer w) = { functor, apply = \mf m -> { value = mf.value m.value, writer = mf.writer <> m.writer }, - wrap = \value -> { value, writer = monoid.empty } + wrap = \value -> { value, writer = monoid.empty }, } let monad : Monad (Writer w) = { applicative, flat_map = \f m -> let { value, writer } = f m.value - { value, writer = m.writer <> writer } + { value, writer = m.writer <> writer }, } { functor, applicative, monad }