trackler 2.2.1.100 → 2.2.1.101

data/tracks/idris/config/exercise_readme.go.tmpl

@@ -4,9 +4,6 @@
 {{- with .Hints }}
 {{ . }}
 {{ end }}
-{{- with .TrackInsert }}
-{{ . }}
-{{ end }}
 {{- with .Spec.Credits -}}
 ## Source
 

data/tracks/idris/docs/INSTALLATION.md

@@ -1,8 +1,11 @@
+## Prerequisites
+
 Before installing Idris, you will need to make sure you have all of the necessary libraries and tools. You will need:
 
  *  A fairly recent Haskell platform. Version 2013.2.0.0 should be sufficiently recent, though it is better to be completely up to date.
  *  The GNU Multiple Precision Arithmetic Library (GMP) is available from MacPorts/Homebrew and all major Linux distributions.
 
+## Idris
 
 The easiest way to install Idris, if you have all of the prerequisites, is to type:
 
@@ -13,3 +16,22 @@ cabal update; cabal install idris
 This will install the latest version released on Hackage, along with any dependencies. 
 If, however, you would like the most up to date development version you can find it, 
 as well as build instructions, on GitHub at: https://github.com/idris-lang/Idris-dev.
+
+## Necessary libraries
+
+You also need to install some Idris libraries, which are requirements of our testsuite.
+
+### `idris-testing`
+
+This library provides the actual testing framework we use. It's installation is pretty simple.
+
+```shell
+pushd /tmp
+git clone git clone git@github.com:jfdm/idris-testing.git
+cd idris-testing
+make lib
+make install # depending on your installation of idris this might need to be run as root
+popd
+```
+
+If the tests will ever brake because of calling things that your installed version of `idris-testing` does not provide, you have to update it by repeating the steps above.

data/tracks/idris/docs/TESTS.md

@@ -1,7 +1,15 @@
-To run tests from the command line:
+## GNU Make
 
-```bash
-idris --testpkg HelloWorld.ipkg
+There is a `Makefile` provided with every exercise, so it is sufficient to simply run
+
+```shell
+make
 ```
 
-(Replace `HelloWorld.ipkg` with the `.ipkg` file in the root directory of each exercise.)
+## Idris-PKG
+
+The `Makefile` mentioned above is just a wrapper around the `idris` executable, which has some simple package management stuff built in.
+
+```shell
+idris --testpkg *.ipkg
+```

data/tracks/idris/exercises/accumulate/src/Accumulate.idr

@@ -0,0 +1,5 @@
+module Accumulate
+
+export
+accumulate : (Int -> Int) -> List Int -> List Int
+accumulate f xs = ?accumulate_rhs

data/tracks/idris/exercises/hamming/Hamming.ipkg

@@ -1,5 +1,7 @@
 package hamming
 
+pkgs = test
+
 sourcedir = src
 modules = Hamming, Test.Hamming
 tests = Test.Hamming.runTests

data/tracks/idris/exercises/hamming/src/{example.idr → Example.idr}

@@ -16,4 +16,8 @@ implementation Eq Nucleotide where
 export
 hamming_distance : Eq a => Vect n a -> Vect n a -> Nat
 hamming_distance s1 s2 = 
-  fst $ filter ((/=) 0) $ map (\(n1,n2) => if n1 == n2 then 0 else 1) $ zip s1 s2
+  fst $ filter ((/=) 0) $ map (\(n1,n2) => if n1 == n2 then 0 else 1) $ zip s1 s2
+
+export
+version : String
+version = "1.0.0"

data/tracks/idris/exercises/hamming/src/Hamming.idr

@@ -2,9 +2,17 @@ module Hamming
 
 import Data.Vect
 
--- Add the correct export modifier here...
-data Nucleotide -- insert definition here
+public export
+data Nucleotide = A | C | G | T
 
--- Add the correct export modifier here...
-hamming_distance : Vect n Nucleotide -> Vect n Nucleotide -> Nat
-hamming_distance s1 s2 = ?hamming_distance_rhs
+public export
+implementation Eq Nucleotide where
+    l == r = ?eq_rhs
+
+export
+hamming_distance : Eq a => Vect n a -> Vect n a -> Nat
+hamming_distance s1 s2 = ?hamming_distance_rhs
+
+export
+version : String
+version = "1.0.0"

data/tracks/idris/exercises/hamming/src/Test/Hamming.idr

@@ -1,66 +1,39 @@
 module Test.Hamming
 
 import Data.Vect
-import Hamming
-
-%access export
-
-assertEq : Eq a => (given : a) -> (expected : a) -> IO ()
-assertEq g e = putStrLn $ if g == e then "Test Passed" else "Test Failed"
-
-testIdenticalStrands : IO ()
-testIdenticalStrands = assertEq (hamming_distance [A] [A]) 0
-
-testLongIdenticalStrands : IO ()
-testLongIdenticalStrands = assertEq (hamming_distance [G,G,A,C,T,G,A] [G,G,A,C,T,G,A]) 0
-
-testDifferentSingleNucleotideStrands : IO ()
-testDifferentSingleNucleotideStrands = assertEq (hamming_distance [A] [G]) 1
-
-testMaximumDistanceInSmallNucleotideStrands : IO ()
-testMaximumDistanceInSmallNucleotideStrands = assertEq (hamming_distance [A,G] [C,T]) 2
-
-testSmallDifferenceInSmallNucleotideStrands : IO ()
-testSmallDifferenceInSmallNucleotideStrands = assertEq (hamming_distance [A,T] [C,T]) 1
+import Test.Assertions
+import System
 
-testSmallDistance : IO ()
-testSmallDistance = assertEq (hamming_distance [G,G,A,C,G] [G,G,T,C,G]) 1
-
-testSmallDistanceInLongStrands : IO ()
-testSmallDistanceInLongStrands = assertEq (hamming_distance [A,C,C,A,G,G,G] [A,C,T,A,T,G,G]) 2
-
-testNonUniqueCharacterInFirstStrand : IO ()
-testNonUniqueCharacterInFirstStrand = assertEq (hamming_distance [A,G,A] [A,G,G]) 1
-
-testNonUniqueCharacterInSecondStrand : IO ()
-testNonUniqueCharacterInSecondStrand = assertEq (hamming_distance [A,G,G] [A,G,A]) 1
-
-testSameNucleotidesInDifferentPositions : IO ()
-testSameNucleotidesInDifferentPositions = assertEq (hamming_distance [T,A,G] [G,A,T]) 2
-
-testLargeDistance : IO ()
-testLargeDistance = assertEq (hamming_distance [G,A,T,A,C,A] [G,C,A,T,A,A]) 4
-
-testLargeDistanceInOffByOneStrand : IO ()
-testLargeDistanceInOffByOneStrand = assertEq (hamming_distance [G,G,A,C,G,G,A,T,T,C,T,G] [A,G,G,A,C,G,G,A,T,T,C,T]) 9
+import Hamming
 
-testEmptyStrands : IO ()
-testEmptyStrands = 
-    let empty = the (Vect _ Nucleotide) [] in
-    assertEq (hamming_distance empty empty) 0
+collect : {default 0 acc : Nat} -> (List (IO Bool)) -> IO Nat
+collect {acc} []               = pure acc
+collect {acc} (test :: tests) = do
+    bool <- test
+    case bool of
+        True  => collect {acc=acc}   tests
+        False => collect {acc=S acc} tests
 
+export
 runTests : IO ()
 runTests = do
-    testIdenticalStrands
-    testLongIdenticalStrands
-    testDifferentSingleNucleotideStrands
-    testMaximumDistanceInSmallNucleotideStrands
-    testSmallDifferenceInSmallNucleotideStrands
-    testSmallDistance
-    testSmallDistanceInLongStrands
-    testNonUniqueCharacterInFirstStrand
-    testNonUniqueCharacterInSecondStrand
-    testSameNucleotidesInDifferentPositions
-    testLargeDistance
-    testLargeDistanceInOffByOneStrand
-    testEmptyStrands
+    let empty = the (Vect _ Nucleotide) []
+    count <- collect
+        [ assertEquals (hamming_distance [A] [A]) 0
+        , assertEquals (hamming_distance [G,G,A,C,T,G,A] [G,G,A,C,T,G,A]) 0
+        , assertEquals (hamming_distance [A] [G]) 1
+        , assertEquals (hamming_distance [A,G] [C,T]) 2
+        , assertEquals (hamming_distance [A,T] [C,T]) 1
+        , assertEquals (hamming_distance [G,G,A,C,G] [G,G,T,C,G]) 1
+        , assertEquals (hamming_distance [A,C,C,A,G,G,G] [A,C,T,A,T,G,G]) 2
+        , assertEquals (hamming_distance [A,G,A] [A,G,G]) 1
+        , assertEquals (hamming_distance [A,G,G] [A,G,A]) 1
+        , assertEquals (hamming_distance [T,A,G] [G,A,T]) 2
+        , assertEquals (hamming_distance [G,A,T,A,C,A] [G,C,A,T,A,A]) 4
+        , assertEquals (hamming_distance [G,G,A,C,G,G,A,T,T,C,T,G] [A,G,G,A,C,G,G,A,T,T,C,T]) 9
+        , assertEquals (hamming_distance empty empty) 0
+        , assertEquals version "1.0.0"
+        ]
+    case count of
+        Z => exitSuccess
+        _ => exitFailure

data/tracks/idris/exercises/hello-world/HelloWorld.ipkg

@@ -1,5 +1,7 @@
 package helloworld
 
+pkgs = test
+
 sourcedir = src
 modules = HelloWorld, Test.HelloWorld
 tests = Test.HelloWorld.runTests

data/tracks/idris/exercises/hello-world/src/Example.idr

@@ -0,0 +1,9 @@
+module HelloWorld
+
+export
+hello : String
+hello = "Hello, World!"
+
+export
+version : String
+version = "1.0.0"

data/tracks/idris/exercises/hello-world/src/HelloWorld.idr

@@ -1,4 +1,9 @@
 module HelloWorld
 
 export
-greet : Maybe String -> String
+hello : String
+hello = ?hello_rhs
+
+export
+version : String
+version = "1.0.0"

data/tracks/idris/exercises/hello-world/src/Test/HelloWorld.idr

@@ -1,25 +1,25 @@
 module Test.HelloWorld
 
-import HelloWorld
-
-%access export
-
-assertEq : Eq a => (given : a) -> (expected : a) -> IO ()
-assertEq g e = putStrLn $ if g == e
-                             then "Test Passed"
-                             else "Test Failed"
+import Test.Assertions
+import System
 
-testNothing : IO ()
-testNothing = assertEq (greet Nothing) "Hello, World!"
-
-testJustAlice : IO ()
-testJustAlice = assertEq (greet (Just "Alice")) "Hello, Alice!"
+import HelloWorld
 
-testJustBob : IO ()
-testJustBob = assertEq (greet (Just "Bob")) "Hello, Bob!"
+collect : {default 0 acc : Nat} -> (List (IO Bool)) -> IO Nat
+collect {acc} []               = pure acc
+collect {acc} (test :: tests) = do
+    bool <- test
+    case bool of
+        True  => collect {acc=acc}   tests
+        False => collect {acc=S acc} tests
 
+export
 runTests : IO ()
 runTests = do
-    testNothing
-    testJustAlice
-    testJustBob
+    count <- collect
+        [ assertEquals hello   "Hello, World!"
+        , assertEquals version "1.0.0"
+        ]
+    case count of
+        Z => exitSuccess
+        _ => exitFailure

data/tracks/idris/exercises/leap/Leap.ipkg

@@ -1,5 +1,7 @@
 package leap
 
+pkgs = test
+
 sourcedir = src
 modules = Leap, Test.Leap
 tests = Test.Leap.runTests

data/tracks/idris/exercises/leap/src/{example.idr → Example.idr}

@@ -6,3 +6,7 @@ isLeap year =
   (divBy 4 && not (divBy 100)) || divBy 400
   where divBy : Int -> Bool
         divBy n = (year `mod` n) == 0
+
+export
+version : String
+version = "1.0.0"

data/tracks/idris/exercises/leap/src/Leap.idr

@@ -2,4 +2,8 @@ module Leap
 
 export 
 isLeap : Int -> Bool
-isLeap year = ?is_leap_year
+isLeap year = ?isLeap_rhs
+
+export
+version : String
+version = "1.0.0"

data/tracks/idris/exercises/leap/src/Test/Leap.idr

@@ -1,37 +1,28 @@
 module Test.Leap
 
-import Leap
-
-%access export
-
-assertBool : Bool -> Bool -> IO ()
-assertBool expected given = putStrLn $ if given == expected then "Test Passed" else "Test Failed"
-
-assertTrue : Bool -> IO ()
-assertTrue = assertBool True
+import Test.Assertions
+import System
 
-assertFalse : Bool -> IO ()
-assertFalse = assertBool False
-
--- year not divisible by 4: common year
-test2015 : IO ()
-test2015 = assertFalse (isLeap 2015)
-
--- year divisible by 4, not divisible by 100: leap year
-test2016 : IO ()
-test2016 = assertTrue (isLeap 2016)
-
--- year divisible by 100, not divisible by 400: common year
-test2100 : IO ()
-test2100 = assertFalse (isLeap 2100)
+import Leap
 
--- year divisible by 400: leap year
-test2000 : IO ()
-test2000 = assertTrue (isLeap 2000)
+collect : {default 0 acc : Nat} -> (List (IO Bool)) -> IO Nat
+collect {acc} []               = pure acc
+collect {acc} (test :: tests) = do
+    bool <- test
+    case bool of
+        True  => collect {acc=acc}   tests
+        False => collect {acc=S acc} tests
 
+export
 runTests : IO ()
 runTests = do
-    test2015
-    test2016
-    test2100
-    test2000
+    count <- collect
+        [ assertFalse (isLeap 2015)
+        , assertTrue  (isLeap 2016)
+        , assertFalse (isLeap 2100)
+        , assertTrue  (isLeap 2000)
+        , assertEquals version "1.0.0"
+        ]
+    case count of
+        Z => exitSuccess
+        _ => exitFailure

data/tracks/idris/exercises/rna-transcription/Makefile

@@ -0,0 +1,23 @@
+idris ?= idris
+pkg   := RnaTranscription
+
+.PHONY: build clean clobber install rebuild test
+
+all: test
+
+build:
+	@ ${idris} --build ${pkg}.ipkg
+
+clean:
+	@ ${idris} --clean ${pkg}.ipkg
+
+clobber: clean
+	@ find . -name '*.ibc' -delete
+
+install:
+	@ ${idris} --install ${pkg}.ipkg
+
+rebuild: clean build
+
+test:
+	@ ${idris} --testpkg ${pkg}.ipkg

data/tracks/idris/exercises/rna-transcription/README.md

@@ -0,0 +1,27 @@
+# Rna Transcription
+
+Given a DNA strand, return its RNA complement (per RNA transcription).
+
+Both DNA and RNA strands are a sequence of nucleotides.
+
+The four nucleotides found in DNA are adenine (**A**), cytosine (**C**),
+guanine (**G**) and thymine (**T**).
+
+The four nucleotides found in RNA are adenine (**A**), cytosine (**C**),
+guanine (**G**) and uracil (**U**).
+
+Given a DNA strand, its transcribed RNA strand is formed by replacing
+each nucleotide with its complement:
+
+* `G` -> `C`
+* `C` -> `G`
+* `T` -> `A`
+* `A` -> `U`
+
+## Source
+
+Rosalind [http://rosalind.info/problems/rna](http://rosalind.info/problems/rna)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/idris/exercises/rna-transcription/RnaTranscription.ipkg

@@ -0,0 +1,5 @@
+package rnatranscription
+
+sourcedir = src
+modules = RnaTranscription, Test.RnaTranscription
+tests = Test.RnaTranscription.runTests

data/tracks/idris/exercises/rna-transcription/src/RnaTranscription.idr

@@ -0,0 +1,17 @@
+module RnaTranscription
+
+import Data.Vect
+
+%access export
+%default total
+
+namespace DnaStrand
+  public export
+  data DnaStrand
+
+namespace RnaStrand 
+  public export
+  data RnaStrand
+
+toRna : Vect n DnaStrand -> Vect n RnaStrand
+toRna = ?toRna_rhs