Löste todos i Dim.ValueLevel

Author: Oskar Lundström

Physics/src/Dimensions/ValueLevel.lhs

@@ -9,9 +9,7 @@ From the introduction, two things became apparanent:
 
 We'll use these facts when implementing dimensions. More precisely, "length" and "metre" will be interchangable, and so on.
 
-TODO: Explain (or link to explanation of) Haskell module syntax, and why you include it.
-
-TODO: I suggest you use the following layout pattern for the module headers (indent 4 spaces, put "where" after the closing paren).
+What you see below is the [Haskell module syntax](http://learnyouahaskell.com/modules#making-our-own-modules). Why do we show it to you? Because we don't want to hide any code from you if you follow along this tutorial.
 
 > module Dimensions.ValueLevel
 >     ( Dim(..)
@@ -56,6 +54,8 @@ Velocity is $m/s$ or equivalently $m^1*s^{ -1 }$. This explains why the exponent
 
 Noticed how we used "m" (for metre) for implicitly refering to the dimension "length"? It's quite natural to work this way.
 
+---
+
 **Exercise.** Create values for acceleration, area and charge.
 
 **Solution.**
@@ -64,6 +64,8 @@ Noticed how we used "m" (for metre) for implicitly refering to the dimension "le
 > area         = Dim 2 0 0    0 0 0 0
 > charge       = Dim 0 0 1    1 0 0 0
 
+---
+
 Multiplication and division
 ---------------------------
 
@@ -73,6 +75,8 @@ Dimensions can be multiplied and divided. Velocity is, as we just saw, a divisio
 > (Dim le1 ma1 ti1 cu1 te1 su1 lu1) `mul` (Dim le2 ma2 ti2 cu2 te2 su2 lu2) =
 >   Dim (le1+le2) (ma1+ma2) (ti1+ti2) (cu1+cu2) (te1+te2) (su1+su2) (lu1+lu2)
 
+---
+
 **Exercise.** Implement a function for dividing two dimensions.
 
 **Solution.**
@@ -81,6 +85,8 @@ Dimensions can be multiplied and divided. Velocity is, as we just saw, a divisio
 > (Dim le1 ma1 ti1 cu1 te1 su1 lu1) `div` (Dim le2 ma2 ti2 cu2 te2 su2 lu2) =
 >   Dim (le1-le2) (ma1-ma2) (ti1-ti2) (cu1-cu2) (te1-te2) (su1-su2) (lu1-lu2)
 
+---
+
 It's now possible to construct dimensions in the following fashion.
 
 > velocity' = length `div` time
@@ -90,32 +96,33 @@ It's now possible to construct dimensions in the following fashion.
 
 TODO: try to replace "since" by "because" (in many places) to avoid confusion with the meaning of "since" in the time-domain.
 
-A dimension we so far haven't mentioned is the *scalar*, which shows up when working with, for example, coefficients of friction. It's dimensionless since it arises from division of two equal dimensions. The case of coefficients of friction looks like
+A dimension we so far haven't mentioned is the *scalar*, which shows up when working with, for example, coefficients of friction. It's dimensionless because it arises from division of two equal dimensions. The case of coefficients of friction looks like
 
 \begin{align}
   F_{friction} = \mu * F_{normal} \iff \mu = \frac{F_{friction}}{F_{normal}}
 \end{align}
 
+---
+
 **Exercise.** Create two values, which represent the scalar. They should of course have the same value, but be created in two different ways. One by writing the exponents explicitly. One by dividing two equal dimensions.
 
 **Solution.**
 
 > one  = Dim 0 0 0 0 0 0 0
 > one' = force `div` force
 
+---
+
 Pretty-printer
 --------------
 
 ![A not so pretty printer](Printer.png){.float-img-left}
 
-The purpose of value-level dimensions is to be able to print 'em nicely. So let's create a pretty-printer.
+The purpose of value-level dimensions is to be able to print 'em nicely. The pretty printer should be function with the type
 
-TODO: move "len" out of the way.
-TODO: I think this code is better left out (not part of the learning outcomes, or something like that). Its type + some example results may be useful, though.
+< showDim :: Dim -> String
 
-> len :: (Integral n) => [a] -> n
-> len [] = 0
-> len (a:as) = 1 + len as
+meaning it shows a dimension as a string. How to actually implement this is not the interesting part in this tutorial, so you may with good conscience skip this implementation. However, if you're curios, you can still take a look at it.
 
 > showDim :: Dim -> String
 > showDim (Dim le ma ti cu te su lu)
@@ -127,23 +134,26 @@ TODO: I think this code is better left out (not part of the learning outcomes, o
 >     pos     = filter (\(_, exp) -> exp >  0) paired
 >     neg     = filter (\(_, exp) -> exp <  0) paired
 >     neg'    = map (\(d, exp) -> (d, -exp)) neg
-
+>
 >     f (u,1) = u
 >     f (u,n) = u ++ "^" ++ show n
-
+>
 >     posStrs = map f pos
 >     negStrs = map f neg'
->     posStr  = if null posStrs -- make a function for this repeated pattern (and use it twice: in posStr ad negStr)
->               then ""
->               else foldl1 (\strs str -> str ++ "*" ++ strs) posStrs
+>     posStr  = strsToStr posStrs
+>     negStr = strsToStr negStrs
 >     (left, right) = if len negStrs > 1
 >                     then ("(", ")")
 >                     else ("", "")
->     negStr = if null negStrs
->              then ""
->              else foldl1 (\strs str -> str ++ "*" ++ strs) negStrs
 >     negStr' = left ++ negStr ++ right
-
+>     strsToStr :: [String] -> String
+>     strsToStr strs = if null strs
+>                      then ""
+>                      else foldl1 (\strs' str -> str ++ "*" ++ strs') strs
+>     len :: (Integral n) => [a] -> n
+>     len [] = 0
+>     len (a:as) = 1 + len as
+>
 > instance Show Dim where
 >   show = showDim
 
@@ -154,8 +164,4 @@ Now dimensions are printed quite pretty in GHCi.
 
 Note that the SI-unit of the dimensions is used for printing.
 
-TODO: Rephrase: if Quantity.lhs really is the "natural" next step, then make it the next step. Otherwise, if it just _seems to be_ the natural next step, explain why your next step is better (more natural?).
-
-The result from this section is the ability to multiply, divide and print dimensions. The next natural step would be to create a data type for quantities. However, we'll first implement type-level dimensions.
-
-TODO: Actually, the real "next step" according to the link is now "Testing of ...". Update the text to match. [Testing seems pretty natural to me.]
+The result from this section is the ability to multiply, divide and print dimensions. The next step is to test these operations and see if they actually work.