carp-lang/Carp
1
1
Fork 0
mirror of https://github.com/carp-lang/Carp.git synced 2024-10-05 17:47:30 +03:00
Code Issues Projects Releases Wiki Activity

chore: Updates Stackage version to 19.2 (#1408)

Browse Source 
* chore: Updates Stackage version to 19.2

Comes with GHC 9.0.2

* refactor: renames list-equal-unordered args

to better fit conventions
This commit is contained in:
Tim Dévé 2022-04-05 10:32:09 +01:00 committed by GitHub
parent 3e5bdc0698
commit 8e8a67d1eb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 102 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/Parsing.hs
View File

@ -627,17 +627,15 @@ balance text =
parens <- Parsec.getState parens <- Parsec.getState
case parens of case parens of
[] -> push c [] -> push c
'"' : xs -> case c of
'\\' -> do
_ <- Parsec.anyChar -- consume next
pure ()
'"' -> Parsec.putState xs -- close string
_ -> pure () -- inside string
(x : xs) -> case (x, c) of (x : xs) -> case (x, c) of
('(', ')') -> Parsec.putState xs ('(', ')') -> Parsec.putState xs
('[', ']') -> Parsec.putState xs ('[', ']') -> Parsec.putState xs
('{', '}') -> Parsec.putState xs ('{', '}') -> Parsec.putState xs
('"', '"') -> Parsec.putState xs ('"', '"') -> Parsec.putState xs -- close string
('"', '\\') -> do
_ <- Parsec.anyChar -- consume next
pure ()
('"', _) -> pure ()
--('\\', _) -> Parsec.putState xs -- ignore char after '\' --('\\', _) -> Parsec.putState xs -- ignore char after '\'
_ -> push c _ -> push c
push :: Char -> Parsec.Parsec String String () push :: Char -> Parsec.Parsec String String ()

2
stack.yaml
View File

@ -15,7 +15,7 @@
# resolver: # resolver:
# name: custom-snapshot # name: custom-snapshot
# location: "./custom-snapshot.yaml" # location: "./custom-snapshot.yaml"
resolver: lts-15.3 resolver: lts-19.2
# User packages to be built. # User packages to be built.
# Various formats can be used as shown in the example below. # Various formats can be used as shown in the example below.

175
test/dynamic_map.carp
View File

@ -1,189 +1,206 @@
(load "Test.carp") (load "Test.carp")
(use Test) (use Test)
(doc list-equal-unordered "Checks two lists have the same values, not necessarily in the same order")
(defndynamic list-equal-unordered [xs ys]
(if (not (= (length xs) (length ys)))
false
(car (reduce (fn [state x]
(let [keep-going (car state)
l (cadr state)]
(if (not keep-going)
'(false ())
(let [index (List.find-index l (curry = x))]
(if (nil? index)
'(false ())
(list true (List.remove-nth l index)))))))
(list true ys)
xs))))
(deftest test (deftest test
(assert-dynamic-equal test (assert-dynamic-equal test
"2" "2"
(Map.get (Map.put (Map.create) "1" "2") "1") (Map.get (Map.put (Map.create) "1" "2") "1")
"basic put and get works" "basic put and get works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
"3" "3"
(Map.get (Map.put (Map.put (Map.create) "1" "2") "1" "3") "1") (Map.get (Map.put (Map.put (Map.create) "1" "2") "1" "3") "1")
"put, update and get" "put, update and get")
)
(assert-dynamic-equal test (assert-dynamic-equal test
nil nil
(Map.get (Map.create) "1") (Map.get (Map.create) "1")
"get works with defaults" "get works with defaults")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.empty? (Map.update (Map.create) "x" inc)) (Map.empty? (Map.update (Map.create) "x" inc))
"update works with empty map" "update works with empty map")
)
(assert-dynamic-equal test (assert-dynamic-equal test
2 2
(Map.get (Map.update {"x" 1} "x" inc) "x") (Map.get (Map.update {"x" 1} "x" inc) "x")
"update works" "update works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
\x \x
(Map.get-with-default {1 \x} 1 \_) (Map.get-with-default {1 \x} 1 \_)
"get-with-default works I" "get-with-default works I")
)
(assert-dynamic-equal test (assert-dynamic-equal test
\_ \_
(Map.get-with-default {1 \x} 2 \_) (Map.get-with-default {1 \x} 2 \_)
"get-with-default works II" "get-with-default works II")
)
(assert-dynamic-equal test (assert-dynamic-equal test
8 8
(Map.get (Map.update-with-default (Map.create) "x" inc 7) "x") (Map.get (Map.update-with-default (Map.create) "x" inc 7) "x")
"update-with-default works with empty map" "update-with-default works with empty map")
)
(assert-dynamic-equal test (assert-dynamic-equal test
2 2
(Map.get (Map.update-with-default {"x" 1} "x" inc 7) "x") (Map.get (Map.update-with-default {"x" 1} "x" inc 7) "x")
"update-with-default works" "update-with-default works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
1 1
(Map.len (Map.put (Map.create) "1" "2")) (Map.len (Map.put (Map.create) "1" "2"))
"len works" "len works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
0 0
(Map.len (Map.create)) (Map.len (Map.create))
"length works on empty map" "length works on empty map")
)
(assert-dynamic-equal test (assert-dynamic-equal test
false false
(Map.contains? (Map.create) "1") (Map.contains? (Map.create) "1")
"contains? works on empty map" "contains? works on empty map")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.contains? (Map.put (Map.create) "1" "2") "1") (Map.contains? (Map.put (Map.create) "1" "2") "1")
"contains? works" "contains? works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.contains? (Map.put (Map.create) -7 "2") -7) (Map.contains? (Map.put (Map.create) -7 "2") -7)
"contains? works with negative keys" "contains? works with negative keys")
)
(assert-dynamic-equal test (assert-dynamic-equal test
false false
(Map.contains? (Map.put (Map.create) 1 "2") -7) (Map.contains? (Map.put (Map.create) 1 "2") -7)
"contains? works with negative keys" "contains? works with negative keys")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.empty? (Map.create)) (Map.empty? (Map.create))
"empty? works on empty map" "empty? works on empty map")
)
(assert-dynamic-equal test (assert-dynamic-equal test
false false
(Map.empty? (Map.put (Map.create) "1" "2")) (Map.empty? (Map.put (Map.create) "1" "2"))
"empty? works" "empty? works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.empty? (Map.remove (Map.put (Map.create) "1" "2") "1")) (Map.empty? (Map.remove (Map.put (Map.create) "1" "2") "1"))
"remove works" "remove works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.all? (fn [p] (or (even? (car p)) (cadr p))) (Map.all? (fn [p] (or (even? (car p)) (cadr p)))
{1 true 2 false 4 false}) {1 true 2 false 4 false})
"Map.all? works I" "Map.all? works I")
)
(assert-dynamic-equal test (assert-dynamic-equal test
false false
(Map.all? (fn [p] (or (even? (car p)) (cadr p))) (Map.all? (fn [p] (or (even? (car p)) (cadr p)))
{1 true 2 false 5 false}) {1 true 2 false 5 false})
"Map.all? works II" "Map.all? works II")
)
(assert-dynamic-equal test (assert-dynamic-equal test
true true
(Map.= {1 2 3 4} {1 2 3 4}) (Map.= {1 2 3 4} {1 2 3 4})
"Map.= works I" "Map.= works I")
)
(assert-dynamic-equal test (assert-dynamic-equal test
false false
(Map.= {1 2 3 4} {1 2 3 5}) (Map.= {1 2 3 4} {1 2 3 5})
"Map.= works II" "Map.= works II")
)
(assert-dynamic-equal test (assert-dynamic-equal test
false false
(Map.= {1 2 3 4} {1 2}) (Map.= {1 2 3 4} {1 2})
"Map.= works III" "Map.= works III")
)
(assert-dynamic-equal test (assert-dynamic-equal test
2 2
(Map.len (Map.from-array [(Pair.init 1 2) (Map.len (Map.from-array [(Pair.init 1 2)
(Pair.init 3 4)])) (Pair.init 3 4)]))
"creating a map from an array works" "creating a map from an array works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
"{ 1 2 }" "{ 1 2 }"
(Map.str (Map.from-array [(Pair.init 1 2)])) (Map.str (Map.from-array [(Pair.init 1 2)]))
"stringification works I" "stringification works I")
)
(assert-dynamic-equal test (assert-dynamic-equal test
; TODO: should we escape strings? ; TODO: should we escape strings?
"{ hi bye }" "{ hi bye }"
(Map.str (Map.from-array [(Pair.init "hi" "bye")])) (Map.str (Map.from-array [(Pair.init "hi" "bye")]))
"stringification works II" "stringification works II")
)
(assert-dynamic-equal test (assert-dynamic-equal test
[(Pair.init 1 2)] [(Pair.init 1 2)]
(Map.to-array (Map.put (Map.create) 1 2)) (Map.to-array (Map.put (Map.create) 1 2))
"Map.to-array works 1" "Map.to-array works 1")
)
(assert-dynamic-equal test (assert-dynamic-equal test
2 2
(length (Map.to-array (Map.from-array [(Pair.init 1 2) (length (Map.to-array (Map.from-array [(Pair.init 1 2)
(Pair.init 3 4)]))) (Pair.init 3 4)])))
"Map.to-array works 2" "Map.to-array works 2")
)
(assert-dynamic-equal test (assert-dynamic-equal test
"{ 1 12 3 34 }" { 1 12 3 34}
(Map.str (Map.map (fn [p] (+ (cadr p) (* 10 (car p)))) {1 2 3 4})) (Map.map (fn [p] (+ (cadr p) (* 10 (car p)))) {1 2 3 4})
"map works" "map works")
)
(assert-dynamic-equal test (assert-dynamic-equal test
641 641
(Map.kv-reduce (fn [sum p] (+ sum (+ (* 100 (car p)) (* 10 (cadr p))))) (Map.kv-reduce (fn [sum p] (+ sum (+ (* 100 (car p)) (* 10 (cadr p)))))
1 1
{1 1 2 1 3 2}) {1 1 2 1 3 2})
"kv-reduce works" "kv-reduce works")
)
(assert-dynamic-equal test (assert-dynamic-op test
'(1 2 3) '(1 2 3)
(Map.keys {1 1 2 1 3 2}) (Map.keys {1 1 2 1 3 2})
"keys works" "keys works"
) list-equal-unordered)
(assert-dynamic-equal test
'(1 1 2) (assert-dynamic-op test
(Map.vals {1 1 2 1 3 2}) '(1 1 2)
"vals works" (Map.vals {1 1 2 1 3 2})
) "vals works"
list-equal-unordered)
(assert-dynamic-equal test (assert-dynamic-equal test
3 3
(Map.get {(Pair.init 1 2) 3} (Pair.init 1 2)) (Map.get {(Pair.init 1 2) 3} (Pair.init 1 2))
"Pairs work as keys" "Pairs work as keys")
)
(assert-dynamic-op test (assert-dynamic-op test
{1 "hi" 2 "bye"} {1 "hi" 2 "bye"}
(Map.reverse {"hi" 1 "bye" 2}) (Map.reverse {"hi" 1 "bye" 2})
"reverse works" "reverse works"
Map.= Map.=)
)
(assert-dynamic-op test (assert-dynamic-op test
{1 "hi" 2 "bye" 3 "!"} {1 "hi" 2 "bye" 3 "!"}
(Map.merge {1 "bye" 3 "!"} {2 "bye" 1 "hi"}) (Map.merge {1 "bye" 3 "!"} {2 "bye" 1 "hi"})
"merge works" "merge works"
Map.= Map.=))
)
)