DEV Community: 齊藤敦志

Rust is very fun

齊藤敦志 — Sat, 02 Jan 2021 13:20:48 +0000

I read books about Haskell.
I thought its type system was great.
However, I couldn't get used to the ML-like syntax.
And side effects in Haskell are too difficult for me.
I am a C/C++ user.

I have found Rust to be a good programming language with a type system similar to Haskell and a C-like syntax.
I tried writing some programs in Rust.
Very fun.
I am frustrated that I do not have the English ability to convey this fun.

Similar thing, not same

齊藤敦志 — Sun, 19 Nov 2017 15:51:43 +0000

Common Lisp has do syntax. And Scheme too.

They have same form, but different semantic.

;; Common Lisp
(do ((i 0 (+ i 1))
     (j '() (cons (lambda()i) j)))
    ((= i 3)
     (mapcar (lambda(x)(funcall x)) j)))
;; → (3 3 3)

;; Scheme
(do ((i 0 (+ i 1))
     (j '() (cons (lambda()i) j)))
    ((= i 3)
     (map (lambda(x)(x)) j)))
;; → (2 1 0)

Scheme's do make a new location every time for each loop. Common Lisp is not so.

Reading text file and split by line

齊藤敦志 — Fri, 17 Nov 2017 18:58:30 +0000

There are many troublesome in text processing in the programming language C. Even just write program that read line by line make time consume. I have read articles that try to implement it.

I have experience to write chat CGI that include line text processing.

Just read the whole file at once by fread.

And replace return to null. It is apparently an array of rows.

The implementation is above.

// whole.h
char** whole(const char* const filename);
void freewhole(char** m);

// whole.c
#include <stdio.h>
#include <stdlib.h>

static long int filesize(FILE* fp) {
  fseek(fp, 0, SEEK_END);
  long int size = ftell(fp);
  fseek(fp, 0, SEEK_SET);
  return size;
}

static int countline(char* block) {
  int line = 0;

  for(int i=0, flag=0; block[i]; i++)
    switch(block[i]) {
    case '\r': line++; flag=1; break;
    case '\n': if(flag) flag = 0; else line++; break;
    default: flag = 0;
    }

  return line+2;
}

static char* nextline(char* str) {
  char* n;
  for(n=str; *n!='\n' && *n!='\r' && *n!='\0'; n++);
  switch(*n) {
  case '\0': return NULL;
  case '\r': *n++='\0'; if(*n=='\n') n++; if(*n=='\0') return NULL; break;
  case '\n': *n++='\0'; if(*n=='\0') return NULL; break;
  }
  return n;
}

static char* readall(const char* const filename) {
  FILE* fp = fopen(filename, "rb");
  if(fp==NULL) {perror(NULL); exit(EXIT_FAILURE); }
  int size = filesize(fp);
  char* block = malloc(size+1);
  if(block==NULL) {perror(NULL); exit(EXIT_FAILURE); }
  int read_size = fread(block, 1, size, fp);
  fclose(fp);
  block[read_size]='\0';
  return block;
}

static char** split(char* block) {
  int linelength=countline(block);
  char** lines = malloc(linelength*sizeof(char*));
  if(lines==NULL) {perror(NULL); exit(EXIT_FAILURE); }
  char** p;
  for(p=lines; block!=NULL; block=nextline(block)) *p++=block;
  *p=NULL;
  return lines;
}

char** whole(const char* const filename) {
  char* block = readall(filename);
  return split(block);
}

void freewhole(char** m) {
  free(m[0]);
  free(m);
}

Example of use.

// example.c
#include <stdio.h>
#include "whole.h"

int main(void) {
  char** lines = whole("test.txt");

  for(int i=0; lines[i]; i++) printf("%d %s\n", i, lines[i]);

  freewhole(lines);

  return 0;
}

Print to console with Chez Scheme and Windows console API.

齊藤敦志 — Fri, 17 Nov 2017 09:00:31 +0000

On Windows, when print character to console via standard output, the character is interpret in current codepage. If encoding of a inner character string is different with current codepage, mojibake will happen. Encoding conversion is necessary.

And, it is impossible to print character that be not contained current codepage via standard output.

For print all unicode characters, we can use console API rather than standard output.

I made console output library with Chez Scheme's foreign interface and console API on Windows.

(library (console-port)
  (export open-console-output-port)
  (import (chezscheme))

  (define dummy (begin (load-shared-object "kernel32.dll") 1))

  (define-ftype handle void*)

  (define open-existing 3)

  (define create-file
    (foreign-procedure __stdcall "CreateFileW"
      (wstring unsigned-32 unsigned-32 void* unsigned-32 unsigned-32 void*)
      void*))

  (define file-share-write 2)

  (define generic-write #x40000000)

  (define (get-active-console-buffer)
    (create-file "CONOUT$" generic-write file-share-write 0 open-existing 0 0))

  (define write-console
    (foreign-procedure __stdcall "WriteConsoleW"
      (void* wstring unsigned-32 u32* void*)
      boolean))

  (define (open-console-output-port)
    (let ((output-handle (get-active-console-buffer))
          (vsize (make-bytevector 4)))
      (define (write-to-console string start count)
        (let ((str (substring string start (+ start count))))
          (write-console output-handle str count vsize 0)
          count))
      (make-custom-textual-output-port "console" write-to-console #f #f #f)))
  )

(import (rnrs)
        (console-port))

(let ((port (open-console-output-port)))
  (display "あいうえお\nかきくけこ\n" port)
  (display "♘♞♙♕♟♝♜♗♛♚♖♔" port)
  (flush-output-port port)) ;; Do not forget the flash!!

My windows computer is setted CP932. CP932 do not contain chess characters. But, it is printable by console API.

Can I hide the type?

齊藤敦志 — Thu, 16 Nov 2017 20:20:12 +0000

Private member is not accessible from outer the class. Private member is inner only unless provide indirect method by pointer or reference.

And I can specify private for type.

For example,

#include <iostream>

class foo {
private:
  class bar {};
public:
  static bar make_bar(void) {
    return bar();
  }
  static void print_bar(bar) {
    std::cout << "bar" << std::endl;
  }
};

I hope hide foo::bar. I do not want you make objects of foo::bar type.

In C++11 and later, you can use private types with auto or decltype.

int main(void) {
  foo::make_bar(); // OK
  foo::print_bar(foo::make_bar()); // OK
  foo::bar x = foo::make_bar();    // Error : foo::bar is private
  auto x = foo::make_bar();        // OK : You can use `auto` in C++11 and later
  decltype(foo::make_bar()) y = foo::make_bar(); // OK : You can use `decltype` in C++11 and later

  return 0;
}

Is there way to hide the type?

Fizz Buzz with compile time programming

齊藤敦志 — Thu, 16 Nov 2017 18:27:22 +0000

Fizz Buzz is screening problem for computer programmers. It is also used for esoteric programming play sometimes.

Kazuho wrote a program to generate a string of Fizz Buzz at compile time in C++. gos-k also wrote in the same concept in Common Lisp.

And I wrote in Scheme (R6RS).

(import (rnrs))

(define-syntax make-fizzbuzz-string
  (lambda(ctx)
    (syntax-case ctx ()
      ((_ n)
       (integer? (syntax->datum #'n))
       (call-with-string-output-port
         (lambda(port)
           (do ((i 1 (+ i 1)))
               ((< (syntax->datum #'n) i))
             (display
              (cond
               ((zero? (mod i 15)) "fizzbuzz")
               ((zero? (mod i 5))  "buzz")
               ((zero? (mod i 3))  "fizz")
               (else i))
              port)
             (newline port))))))))

(define (fizzbuzz)
  (display (make-fizzbuzz-string 100)))

(fizzbuzz)

For compile-time programming, LISP is much easier than C++.