trackler 2.2.1.15 → 2.2.1.16

data/tracks/scala/testgen/src/main/scala/PigLatinTestGenerator.scala

@@ -0,0 +1,16 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object PigLatinTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/pig-latin.json")
+
+    val code =
+      TestSuiteBuilder.build(file, fromLabeledTest("input"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scheme/docs/SNIPPET.txt

@@ -0,0 +1,7 @@
+(define-module (hello-world)
+  #:export (hello))
+
+(define hello
+  (lambda* (#:optional name)
+    (let ((target (or name "World")))
+      (string-concatenate (list "Hello, " target "!")))))

data/tracks/sml/bin/generate

@@ -0,0 +1,277 @@
+#!/usr/bin/env python
+
+import json
+import re
+import shutil
+
+from pathlib import Path
+from collections import OrderedDict
+from urllib.request import urlopen, HTTPError
+from http import HTTPStatus
+
+
+canonical_data_url = 'https://raw.githubusercontent.com/exercism' + \
+                     '/problem-specifications/master' + \
+                     '/exercises/%s/canonical-data.json'
+
+
+def fetch(exercise):
+    try:
+        with urlopen(canonical_data_url % exercise) as response:
+            return json.loads(response.read().decode('utf8'))
+    except HTTPError as e:
+        if e.status == HTTPStatus.NOT_FOUND.value:
+            msg = "Exercise '%s' doesn't exist." % exercise
+        else:
+            msg = 'Unexpected error, please try again later.'
+        raise Exception(msg)
+
+
+def load(exercise):
+    root = Path(__file__).absolute().parent.parent.parent
+    path = root / 'problem-specifications/exercises'
+    with (path / exercise / 'canonical-data.json').open() as f:
+        return json.loads(f.read())
+
+
+def indent(n, s):
+    return s.rjust(len(s) + n, ' ')
+
+
+def camelize(s):
+    return re.sub('[-_](\w)', lambda x: x.group(1).upper(), s)
+
+
+def sml_type(value):
+    if value is None:
+        return 'option'
+    if isinstance(value, list):
+        if not value:
+            return "'a list"
+        s = {sml_type(v)
+             for v in value
+             # }
+             if not (isinstance(v, list) and not v)}
+        s.discard('exn')
+        if not s or len(s) > 2:
+            raise Exception('Failed to infer a proper type')
+        if len(s) == 1:
+            return '%s list' % s.pop()
+        if 'option' not in s:
+            raise Exception('Failed to infer a proper type, got multiple types', value, s)
+        s.remove('option')
+        return '%s option list' % s.pop()
+    if isinstance(value, dict):
+        if 'error' in value:
+            return 'exn'
+        return '{%s}' % ', '.join(
+            '%s: %s' % (key, sml_type(value[key]))
+            for key in sorted(value.keys())
+        )
+    types = {int: 'int', str: 'string', float: 'real', bool: 'bool'}
+    return types[type(value)]
+
+
+def sml_value(value, smltype=''):
+    if value is None:
+        return 'NONE'
+    _value = None
+    if isinstance(value, str):
+        _value = json.dumps(value)
+    if isinstance(value, bool):
+        _value = str(value).lower()
+    if isinstance(value, (int, float)):
+        if value < 0:
+            _value = '~%s' % -value
+        else:
+            _value = str(value)
+    if isinstance(value, list):
+        _value = '[%s]' % ', '.join(sml_value(v) for v in value)
+    if isinstance(value, dict):
+        if 'error' in value:
+            return 'Fail "%s"' % value['error']
+        _value = '{%s}' % ', '.join('%s = %s' % (k, sml_value(v))
+                                  for k, v in value.items())
+    return _value if 'option' not in smltype else ('SOME ' + _value)
+
+
+def get_fn_args(case):
+    ignored_keys = {'property', 'expected', 'description', 'comments'}
+    return OrderedDict(
+        (k, case[k])
+        for k in sorted(case.keys())
+        if k not in ignored_keys
+    )
+
+
+def extract_signatures(data):
+    funcs = OrderedDict()
+    exercise = data['exercise']
+    ignored_keys = {'property', 'expected', 'description', 'comments'}
+
+    def type_aux(values):
+        s = {sml_type(val) for val in values}
+        if len(s) == 1:
+            return s.pop()
+        if len(s) == 2 and 'option' in s:
+            s.remove('option')
+            return '%s option' % s.pop()
+        raise Exception('Failed to infer a proper type, can not unify different types: %s' % s)
+
+    def signature(xs):
+        output = []
+        args = OrderedDict()
+        for x in xs:
+            output.append(x['output'])
+            for arg, val in x['args'].items():
+                args.setdefault(arg, []).append(val)
+        return {
+            'args': OrderedDict((arg, type_aux(vals)) for arg, vals in args.items()),
+            'output': type_aux(output),
+        }
+
+    def collect(cases):
+        for case in cases:
+            if 'cases' in case:
+                collect(case['cases'])
+            else:
+                # assumes there's at least one test with non "nullish" vars
+                fn = camelize(case.get('property', exercise))
+                if sml_type(case['expected']) == 'exn':
+                    continue
+                args = get_fn_args(case)
+                if not all(args.values()) or sml_type(case['expected']) == "'a list":# or not case['expected']:
+                    continue
+                funcs.setdefault(fn, []).append({
+                    'args': args,
+                    'output': case['expected']
+                })
+
+    collect(data['cases'])
+    return {fn: signature(funcs[fn]) for fn in funcs}
+
+
+def expectation(signature, fn, args, expected):
+    tmpl = '(fn _ => %s |> Expect.%s)'
+    output = sml_value(expected, signature['output'])
+    invocation = '%s (%s)' % (
+        fn,
+        ', '.join((
+            sml_value(val, signature['args'][arg])
+            for arg, val in args.items())
+        )
+    )
+    if sml_type(expected) == 'exn':
+        return tmpl % (
+            '(fn _ => %s)' % invocation,
+            'error (%s)' % output
+        )
+    if signature['output'] == 'bool':
+        return tmpl % (
+            invocation,
+            'truthy' if expected else 'falsy'
+        )
+    if signature['output'] == 'real':
+        return tmpl % (
+            invocation,
+            'nearTo %s' % output
+        )
+    return tmpl % (
+        invocation,
+        ('equalTo (%s)' if 'SOME ' in output else 'equalTo %s') % output
+    )
+
+
+def generate_test_content(data, signature):
+    exercise = data['exercise']
+
+    def fmt(case, depth=0):
+        if 'property' not in  case:
+            print('WARNING: property not found using exercise name as function name')
+        fn = camelize(case.get('property', exercise))
+        expected = case['expected']
+        args = get_fn_args(case)
+        return '\n'.join((
+            indent(depth, 'test "%s"' % case.get('description', fn)),
+            indent(depth + 2, expectation(signature[fn], fn, args, expected))
+        ))
+
+    def traverse(cases, depth=0):
+        acc = []
+        for case in cases:
+            if 'cases' in case:
+                acc.append('\n'.join((
+                    indent(depth * 2, 'describe "%s" [' % case['description']),
+                    ',\n\n'.join(traverse(case['cases'], depth + 1)),
+                    indent(depth * 2, ']')
+                )))
+            else:
+                acc.append(fmt(case, depth * 2))
+        return acc
+
+    return '\n'.join([
+        '(* version %s *)' % data['version'],
+        '',
+        'use "%s.sml";' % data['exercise'],
+        'use "testlib.sml";',
+        '',
+        'infixr |>',
+        'fun x |> f = f x',
+        '',
+        'val testsuite =',
+        '  describe "%s" [' % data['exercise'],
+        ',\n\n'.join(traverse(data['cases'], depth=2)),
+        '  ]',
+        '',
+        'val _ = Test.run testsuite'
+    ])
+
+
+def generate_exercise_content(signatures):
+    def fmt(args):
+        return ', '.join('%s: %s' % (name, value)
+                        for name, value in args.items())
+
+    return '\n\n'.join(
+        'fun {0} ({1}): {2} =\n'
+        '  raise Fail "\'{0}\' is not implemented"'.format(
+            fn,
+            fmt(signature['args']),
+            signature['output']
+        )
+        for fn, signature in signatures.items()
+    )
+
+
+def write(path, content):
+    with path.open('w') as f:
+        f.write(content)
+
+
+def generate(exercise):
+    root = Path(__file__).parent.parent.absolute()
+    path = root / 'exercises' / exercise
+    if not path.exists():
+        path.mkdir()
+    data = fetch(exercise)
+    signatures = extract_signatures(data)
+    write(path / 'test.sml', generate_test_content(data, signatures))
+    content = generate_exercise_content(signatures)
+    write(path / ('%s.sml' % exercise), content)
+    write(path / 'example.sml', content)
+    shutil.copyfile(
+        (root / 'lib/testlib.sml').as_posix(),
+        (path / 'testlib.sml').as_posix()
+    )
+
+
+if __name__ == '__main__':
+    import sys
+
+    for exercise in sys.argv[1:]:
+        try:
+            generate(exercise)
+        except FileNotFoundError:
+            print('[%s]: canonical-data.json not found' % exercise)
+        except Exception as e:
+            print('[%s]: %s' % (exercise, e))

data/tracks/sml/config.json

@@ -4,6 +4,26 @@
   "active": false,
   "test_pattern": "test[.]sml$",
   "exercises": [
+    {
+      "uuid": "4450455d-0786-6f80-7672-48368a115df16e0aa7e",
+      "slug": "hello-world",
+      "core": true,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
+    {
+      "uuid": "9d8e76f1-0e85-a280-b779-16335f29d1a96ce3a72",
+      "slug": "bob",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "333c2cb9-f03c-473c-9eeb-096072a321b2",
       "slug": "accumulate",
@@ -74,6 +94,16 @@
 
       ]
     },
+    {
+      "uuid": "b6713a74-08d5-4480-6524-f9dbf5cf2563d2b2a91",
+      "slug": "difference-of-squares",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "225cfd7d-81a3-4a58-b1aa-1de2e40e7a93",
       "slug": "binary",

data/tracks/sml/docs/ABOUT.md

@@ -0,0 +1,32 @@
+[Standard ML (SML)](https://en.wikipedia.org/wiki/Standard_ml) is one of the two main dialects of the ML programming
+language. [ML](https://en.wikipedia.org/wiki/ML_programming_language) was the first strong statically typed language,
+developed in the early 1970s at the University of Edinburgh. 
+
+Despite it's age, SML feels very young in many ways; SML had features that mainstream languages would not pick up for decades and are still being experimented with today.
+
+Here are some of ML's "cutting-edge" features:
+
+- [**strong** static typing](https://en.wikipedia.org/wiki/Type_system#Static_typing)
+- [automatic type inference](https://en.wikipedia.org/wiki/Type_inference)
+- exception handling
+- [pattern matching](https://en.wikipedia.org/wiki/Pattern_matching)
+- parametric polymorphism
+- [first class functions](https://en.wikipedia.org/wiki/First-class_function)
+
+SML was originally designed for developping proofs about first-order predicate calculus (read: _computer programs_)
+and it can have a distinct academic feel about it.
+
+However it's emphasis on immutability and strong typing has led SML to be used in many fields where program correctness is paramount (compiler design, code analysis, financial systems, medical systems, etc...).
+
+Learning SML makes you a better programmer, because it forces you to write code that is stateless and to use closures
+effectively.
+
+It's also many programmers first introduction to pattern matching and (truely) strong typing. And because SML's type system is so strong and well-thought out, it often feels like you are working in a dynamically typed language instead.
+
+There are several popular implementations:
+
+- [MLton](http://mlton.org/)
+- [SML/NJ](http://www.smlnj.org/)
+- [PolyML](http://www.polyml.org/). 
+
+You can find information on the language on each implementation's sites. 

data/tracks/sml/docs/LEARNING.md

@@ -0,0 +1,37 @@
+## Recommended Learning Resources
+
+Exercism provides exercises and feedback but ML can be difficult to jump into for those learning SML for the first time. 
+These resources can help you get started:
+
+### I've never programmed before
+
+ML is probably not the best language for new programmers. You are probably better off starting with a language like
+Ruby or Python, but if you are feeling particularly bold you might want to read [Programming in Standard ML '97:
+An On-line Tutorial](https://www.cs.cmu.edu/~rwh/introsml/) I suggest skipping the introduction and jumping straight
+to [Simple applicative programming ](http://homepages.inf.ed.ac.uk/stg/NOTES/node13.html), because the introduction
+is very technical.
+
+Coursera offers a course on [programming languages](https://www.coursera.org/learn/programming-languages). 
+The course is aimed at somewhat experienced programmers, but it's hard to find a better introduction to the ML language.
+
+
+### I've heard of functional programming
+
+A good read is [Programming in Standard ML '97: An On-line Tutorial](https://www.cs.cmu.edu/~rwh/introsml/).
+
+Another is [A Gentle Introduction to ML](http://www.soc.napier.ac.uk/course-notes/sml/manual.html).
+
+Coursera offers a course on [programming languages](https://www.coursera.org/learn/programming-languages).
+It's hard to find a better introduction to the ML language.
+
+The [SML/NJ site](http://smlnj.org/doc/literature.html) lists a number of books. Most are quite old and are probably hard to find though.
+The language hasn't changed much so if you can find them, don't think that they are that out of date. Also check the 
+Four Lectures on Standard ML listed on the page.
+
+
+## I am a confident programmer
+
+If you are a confident programmer and if you are very familiar with functional languages, than you can get a good overview of the
+syntax at [Learn X in Y minutes](https://learnxinyminutes.com/docs/standard-ml/)
+
+The [Four Lectures on Standard ML](http://smlnj.org/doc/literature.html) are a good introduction.

data/tracks/sml/docs/SNIPPET.txt

@@ -0,0 +1,3 @@
+fun fib 0 = 0
+  | fib 1 = 1
+  | fib n = fib (n - 1) + fib (n - 2)

data/tracks/sml/exercises/bob/README.md

@@ -0,0 +1,48 @@
+# Bob
+
+Bob is a lackadaisical teenager. In conversation, his responses are very limited.
+
+Bob answers 'Sure.' if you ask him a question.
+
+He answers 'Whoa, chill out!' if you yell at him.
+
+He says 'Fine. Be that way!' if you address him without actually saying
+anything.
+
+He answers 'Whatever.' to anything else.
+
+## Loading your exercise implementation in PolyML
+
+```
+$ poly --use {exercise}.sml
+```
+
+Or:
+
+```
+$ poly
+> use "{exercise}.sml";
+```
+
+**Note:** You have to replace {exercise}.
+
+## Running the tests
+
+```
+$ poly -q --use test.sml
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/sml](https://github.com/exercism/sml) repository on
+GitHub is the home for all of the Standard ML exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue. We'll do our best to help you!
+
+## Source
+
+Inspired by the 'Deaf Grandma' exercise in Chris Pine's Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=06](http://pine.fm/LearnToProgram/?Chapter=06)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.