Real Point-free Haskell Program

Hi, it is NISHIO Hirokazu. I'm trying to make *REAL* point-free Haskell program. In other words, I want to make point-free (arguments-less) Haskell code with any point(.)

You may know, usually most of Haskell programmer use (.) operator to combine functions. However, it is not necessary. It can replace with (<*>) and const.

Prelude Control.Applicative> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c
Prelude Control.Applicative> :t \x y z -> (const x <*> y) z
\x y z -> (const x <*> y) z :: (a -> b) -> (b1 -> a) -> b1 -> b

So anytime you want to use (.) operator, you can do it without (.)

Prelude Control.Applicative> (map . (+)) 1 [1, 2, 3]
[2,3,4]
Prelude Control.Applicative> (const map <*> (+)) 1 [1, 2, 3]
[2,3,4]

And it is also easy to remove points from float expression:

Prelude> 1.5
1.5
Prelude> 15e-1
1.5

The most biggest problem is how to remove this point.

import Control.Applicative
              ^

Haskell Quiz

Hi, it is Dr. NISHIO Hirokazu. Today I made a quiz. See following code and answer the definitions of a, b, c and d.

main = do
  print $ a + c == 0 -- True.
  print $ a == c     -- True. a == c == 0.
  print $ c == 0     -- True. Of course.
  print $ a + d == 1 -- True. d == 1.
  print $ b + c == 1 -- True. b == 1.
  print $ b + d == 0 -- True. What happened?!
  print $ b == d     -- True. ?!
  print $ d == 0     -- True. ?!?!
  -- hints to make answer unique (perhaps...)
  print $ sum([a, b, c])  -- 1
  print $ sum([a, b, d])  -- 1
  print $ [a, b, c] !! a  -- 0
  print $ [a, b, c] !! b  -- 1
  print $ [a, b, c] !! c  -- 0

I swear:

• I didn't define (+)
  
• I didn't define (!!)
  
• I didn't define (==)
  
• I didn't define sum
  
• I didn't define print
  
• I didn't define ($) -- @kmizu sent me a valid solution and he defined ($). I didn't.
  
• I didn't use default -- @camlspotter said it may use defaulting, and I didn't know it. I agree with him that it would be easier if I used defaulting. But I didn't. I didn't use default defaulting (i.e. default ordering of Integer and Double) For more detail, see http://www.haskell.org/onlinereport/decls.html#sect4.3.4
  

All of them are original, came from the prelude module.

The answer will be published on the blog at least 1 week after.

PONG-like game played on iPad with tangible controller

Hi, it is NISHIO Hirokazu. Today I introduce my recent demo movie of Muroto system. Using MUROTO you can controll games on iPad with tangible figures. There are "Muroto device" under the figures. And "Muroto library" tells the type of figures you put on iPhone, the direction and position.

It's not jail-braked. See further information on http://www.nishiohirokazu.org/muroto/

Another Demo movie of "Muroto for iPad"

Hi, it is NISHIO Hirokazu. I posted Hacker's Cafe Blog: MUROTO: tangible figure as a controller for iPad apps, however it said difficult to see that Muroto can get the information of position and direction. So I made another demo program and movie again!

In the movie, it is more clear:

MUROTO: tangible figure as a controller for iPad apps

Hi, it is NISHIO Hirokazu. I and KUCHII Jun made a system to control iPhone/iPad apps with tangible figure for "Make: Tokyo Meeting 05" on the last Sunday. We called it "MUROTO". Using MUROTO you can know the type of figure you put on iPhone, the direction and also position(not shown in movie)
So you can use tangible figures as a controller! We are making demo apps for iPad now. Don't miss it! See also: PONG-like game played on iPad with tangible controller

13 chars in [4,+,-,*,/] can make all number in range(60)

Hi, it is Dr. NISHIO Hirokazu. Today I wonder how much characters required to make fixed-width one-digit-only digital clock. Which digit is the most suitable?

When I allow to use bitwise calculation, 5 is the most suitable digit. It requires only 8 characters.

0       555/5555
1       ~~-5+-~5
2       -~-5+-~5
3       555&5*55
...

Surprisingly in the hardest restriction it requires only 13 characters.

• no bitwise operation. allow only the 4 arithmetical operations.
  
• no minus-minus connection. 4--4 = 4 - -4 is not allowed
  
• negate operation should not be aside of the other operation. 4+-4, 4*-4, 4/-4 are also omitted
  
• true division. 4 / 44 is not 0, it is 1 / 11.
  

Here is the result. I think 37 == 4444/44-4*4*4 is very cute!! I love it!

0 4444*4-4*4444
1 44-44+444/444
2 4/4+4444/4444
3 44/44+4/4+4/4
4 4-4/4+444/444
5 4-4-4+4+4+4/4
6 4-4/4+4-44/44
7 -4-44+44+44/4
8 4-4*44+44*4+4
9 4-4+4+4+44/44
10 444/4-4444/44
11 -4+4-4+4+44/4
12 4-4-4-4+4*4+4
13 4-4-4+4*4+4/4
14 4-4/44+444/44
15 4-4+4*4-44/44
16 -4-4-4-4*4+44
17 4*4+4444/4444
18 4+4*4-4/4-4/4
19 -44+4*4*4-4/4
20 4-4/4+4*4+4/4
21 4-4+4+4*4+4/4
22 4-4+44/4+44/4
23 4+4+4*4-44/44
24 4-44+44+4*4+4
25 -4-4*4+44+4/4
26 -4/4+4*4+44/4
27 -4+4*4+4+44/4
28 4*4-4-4+4*4+4
29 4-4-4-44/4+44
30 4+4+44/4+44/4
31 4*4+4*4-44/44
32 44-44/4-44/44
33 44/44+4*4+4*4
34 44+44/44-44/4
35 -44/44-4-4+44
36 -44-4-4+44+44
37 4444/44-4*4*4
38 4-44/4+44+4/4
39 -4-4+4-4/4+44
40 -4*4-4+4*4+44
41 -4+44+444/444
42 -4+44+4/4+4/4
43 -4+44+4-44/44
44 -4*44+44*4+44
45 -44+44+44+4/4
46 -4/4-4/4+4+44
47 -4-4/4+4+44+4
48 -4-4-4+4*4+44
49 -44/4-4+4*4*4
50 44-4-4/4+44/4
51 4+44+44/4-4-4
52 -44+4+44+44+4
53 44+4+4*4-44/4
54 44+44/4-44/44
55 44-44+44+44/4
56 4-4-4-4+4*4*4
57 4/4-4-4+4*4*4
58 4-4/4+44+44/4
59 44+4-4+4+44/4

see also The list of all numbers which can generate from nine 4s and arithmetics operations.

What happen if you put both str and unicode key on a dict in Python?

In [1]: {u"a": 1, "a": 2}
Out[1]: {u'a': 2}

Yas, it is because:

In [2]: u"a" == "a"
Out[2]: True

Python2.* think u"a" and "a" are EQUAL. of course:

In [3]: u"a" is "a"
Out[3]: False

they are not IDENTITY. If Guido designed to use IDENTITY to check whether they are SAME key, it causes:

In [4]: (1, 2) is (1, 2)
Out[4]: False

that uncomfortable behavior. We don't want to distinguish EQUAL tuples. It is a difficult question on designing new languages. Those behavior was changed from Python3.0. On it, bytes(byte sequence) and text(unicode char sequence) are not compatible. No automatic conversion between them.

>>> b"a" == "a"
False
>>> {b"a": 1, "a": 2}
{b'a': 1, 'a': 2}