Por que a informação do tipo na caixa vermelha não é: 'a -> 'a -> 'a -> 'a -> 'a?
Acho que todos os parâmetros e o valor de retorno devem ser do mesmo tipo, e o utop confirma que todos eles são do mesmo Z.ttipo.
utop # let rec fib_acc = fun n -> fun n_1 -> fun n_2 -> fun acc ->
if (Z.equal n Z.one) || (Z.equal n (Z.of_int 2))
then acc
else fib_acc (Z.add n Z.minus_one) n_2 (Z.add n_1 n_2) (Z.add n_1 n_2);;
val fib_acc : Z.t -> Z.t -> Z.t -> Z.t -> Z.t = <fun>
Estou tentando escrever um código executável simples em OCaml abaixo.
open Printf
open Lwt
open Cohttp
open Cohttp_lwt_unix
open Yojson
let () =
let ip = "8.8.8.8" in
let key = "" in
let uri =
Uri.of_string
("https://api.ip2location.io/?format=json&key=" ^ key ^ "&ip=" ^ ip)
in
Lwt_main.run
( Client.get uri >>= fun (resp, body) ->
let code = resp |> Response.status |> Code.code_of_status in
let json_promise = body |> Cohttp_lwt.Body.to_string in
json_promise >>= fun json_string ->
let json = Basic.from_string json_string in
let open Yojson.Basic.Util in
if code == 200 then
if member "usage_type" json <> `Null then
let usage_type = json |> member "usage_type" |> to_string in
printf "usage_type: %s\n" usage_type
else
printf
"ERROR: The usage_type field requires a paid subscription to the \
Starter plan or higher."
else if (code == 400 || code == 401) && member "error" json <> `Null then
let error_message =
json |> member "error" |> member "error_message" |> to_string
in
printf "ERROR: " ^ error_message
else printf "HTTP Code: " ^ Int.to_string code )
Mas continuo vendo o seguinte quando executo dune build.
File "bin/main.ml", line 24, characters 10-46:
24 | printf "usage_type: %s\n" usage_type
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Error: This expression has type unit but an expression was expected of type
'a Client.io
Em outras postagens do StackOverflow, parece estar relacionado aos diferentes tipos retornados no , if/elsemas me certifiquei de que todos eles if/elseestão usando printf.
Eu agradeceria se alguém pudesse me dizer o que mais estou fazendo errado.
(Estou aprendendo OCaml e essa pode ser uma pergunta ingênua.)
Eu uso o código abaixo para definir uma função nomeada a:
utop # let a = fun x -> x+1;;
val a : int -> int = <fun>
Observe que o espaçamento entre linhas val aaparece claramente como o nome da função.
Então tentei ver as informações do tipo da função a:
utop # a;;
- : int -> int = <fun>
Há um -, que significa anônimo.
Mas eu dei um nome a ele a.
Por que não é exibido?
Estou escrevendo código de teste para meu projeto OCaml e, ao usar o código abaixo, ele funciona bem.
open Printf
open Ip2location
(* query IP2Location BIN datababase *)
let meta = Database.open_db "./IP2LOCATION-LITE-DB1.IPV6.BIN";;
let ip = "2a02:3037:0400:6fa2:459c:84b6:967d:69e0";;
let res = Database.query meta ip;;
printf "country_short: %s\n" res.country_short;;
printf "country_long: %s\n" res.country_long;;
printf "region: %s\n" res.region;;
printf "city: %s\n" res.city;;
printf "isp: %s\n" res.isp;;
printf "latitude: %f\n" res.latitude;;
printf "longitude: %f\n" res.longitude;;
printf "domain: %s\n" res.domain;;
printf "zip_code: %s\n" res.zip_code;;
printf "time_zone: %s\n" res.time_zone;;
printf "net_speed: %s\n" res.net_speed;;
printf "idd_code: %s\n" res.idd_code;;
printf "area_code: %s\n" res.area_code;;
printf "weather_station_code: %s\n" res.weather_station_code;;
printf "weather_station_name: %s\n" res.weather_station_name;;
printf "mcc: %s\n" res.mcc;;
printf "mnc: %s\n" res.mnc;;
printf "mobile_brand: %s\n" res.mobile_brand;;
printf "elevation: %f\n" res.elevation;;
printf "usage_type: %s\n" res.usage_type;;
printf "address_type: %s\n" res.address_type;;
printf "category: %s\n" res.category;;
printf "district: %s\n" res.district;;
printf "asn: %s\n" res.asn;;
printf "as: %s\n" res.asys;;
Database.close_db meta;;
Então, modifiquei o código para consultar uma lista de endereços IP como abaixo:
open Printf
open Ip2location
(* query IP2Location BIN datababase *)
let meta = Database.open_db "./IP2LOCATION-LITE-DB1.IPV6.BIN";;
let mylist = ["0.0.0.0"; "8.3.34.0"; "8.8.8.8"; "3.91.171.8"; "37.252.228.50"; "64.94.62.0"; "197.85.191.64"; "255.255.255.254"; "255.255.255.255"; "179.125.12.0"; "::"; "2001::"; "2001:0:4136:e378:8000:63bf:f7f7:f7f7"; "2001:0000:4136:e378:8000:63bf:f7fc:ddff"; "2002::"; "2002:808:808::"; "2002:0803:2200::0803:2200"; "2600:1F18:45B0:5B00:0000:0000:0000:0000"; "::FFFF:FFFF"; "::FFFF:3.91.171.8"; "::FFFF:8.3.34.0"; "::FFFF:64.94.62.0"; "::FFFF:C555:BF40"; "ffff:ffff:ffff:ffff:FFFF:FFFF:FFFF:FFFE"; "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF"; "0:0:0:0:0:ffff:b37d:0c00"; "0.0.0.256"; "0.0.0"; "1"; "A"];;
let getloc ip =
let res = Database.query meta ip in
printf "country_short: %s\n" res.country_short;;
printf "country_long: %s\n" res.country_long;;
printf "region: %s\n" res.region;;
printf "city: %s\n" res.city;;
printf "isp: %s\n" res.isp;;
printf "latitude: %f\n" res.latitude;;
printf "longitude: %f\n" res.longitude;;
printf "domain: %s\n" res.domain;;
printf "zip_code: %s\n" res.zip_code;;
printf "time_zone: %s\n" res.time_zone;;
printf "net_speed: %s\n" res.net_speed;;
printf "idd_code: %s\n" res.idd_code;;
printf "area_code: %s\n" res.area_code;;
printf "weather_station_code: %s\n" res.weather_station_code;;
printf "weather_station_name: %s\n" res.weather_station_name;;
printf "mcc: %s\n" res.mcc;;
printf "mnc: %s\n" res.mnc;;
printf "mobile_brand: %s\n" res.mobile_brand;;
printf "elevation: %f\n" res.elevation;;
printf "usage_type: %s\n" res.usage_type;;
printf "address_type: %s\n" res.address_type;;
printf "category: %s\n" res.category;;
printf "district: %s\n" res.district;;
printf "asn: %s\n" res.asn;;
printf "as: %s\n" res.asys
List.iter getloc mylist;;
Database.close_db meta;;
Quando eu corri dune test, obtive o seguinte:
File "test/ip2locationtest.ml", line 12, characters 29-32:
12 | printf "country_long: %s\n" res.country_long;;
^^^
Error: Unbound value res
Hint: Did you mean ref?
Sou novato em OCaml, então não tenho certeza do que estou perdendo. Agradeceria qualquer dica sobre o que estou fazendo errado.
let x = 2;;
let x = 3
in let y = x +1
in x + 1;;
let x = 3 and y = x + 1
in x + y;;
Os resultados são ordenados respectivamente para cada expressão:
val x : int = 2
- : int = 7
- : int = 6
Você pode me ajudar a entender por que a última expressão é igual a 6? É difícil para mim entender.
Eu executo esse código no tryOCamlpro.
Na minha prática de programação em OCaml, descobri recentemente que o seguinte operador de pipeline é muito útil para criar funções.
let (>|) f g x = g (f x)
val ( >| ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c = <fun>
Eu o uso para substituir códigos como:
fun s -> int_of_string s |> Int.hash
- : string -> int = <fun>
Pelo mais simples:
int_of_string >| Int.hash
- : string -> int = <fun>
A associatividade funciona bem:
int_of_string >| float_of_int >| string_of_float
- : string -> string = <fun>
Isso seria uma melhoria valiosa da linguagem principal e, se sim, como enviar essa contribuição?
Gostaria de ajuda para entender como a inferência de tipo afeta o código a seguir, que vem de uma pergunta anterior (que, após algumas reflexões, simplifiquei para o seguinte):
type 'a result =
| Succ of 'a
| Fail
let first f = function
| Succ c -> let res = f c in Succ res
| fail -> fail
let second f = function
| Succ c -> let res = f c in Succ res
| Fail -> Fail
Minha pergunta é: por que fin firsthave type ('a -> 'a)mas fin secondhave type ('a -> 'b)?
Você pode vê-lo aqui .
Estou tentando criar um tipo de soma local dentro de uma função e, em seguida, retornar o referido tipo de soma sem que ele seja declarado em main. Isso é possível? Não acredito que seja diretamente, mas tenho brincado com GADTs e variantes polimórficas para tentar encontrar uma solução alternativa, mas ainda sou relativamente novo no OCaml e não os entendo completamente.
O que eu quero que a função faça é o seguinte. Dada uma tupla do tipo ('a, 'b), retorne o primeiro elemento, mas com o tipo da soma entre 'ae 'b.
Pela resposta de gallais , tentei trabalhar type ('a, 'b) either = | Left of 'a | Right of 'b, mas não consegui fazê-lo funcionar.
Editar: em resposta ao comentário de Glennsl, o problema que estou tentando resolver é para o meu projeto de curso. Estou tentando implementar o isomorfismo Curry-Howard entre Lógica Construtiva e programas. Atualmente, consegui que o provador de teoremas funcionasse, bem como a extração do programa, mas estou lutando para converter a forma abstrata de um programa em código OCaml ao lidar com as regras de disjunção. O conjunto de regras que estou usando vem da página 34 deste documento . Incluí uma imagem das regras de disjunção .
O exemplo que perguntei é o teorema (anb) -> (avb). Existem duas provas que fazem sentido, e escolhi aquela que utiliza a regra vI L , que corresponde à injeção da soma à esquerda da variável do tipo A em um tipo soma com duas componentes, A e B. O programa representado por esta teorema (usando esta regra), é uma função que recebe uma tupla e retorna o primeiro elemento, mas com o tipo de soma A + B. Gostaria de ajuda vindo do código OCaml para esta função de exemplo. Depois de entender isso, espero ser capaz de generalizá-lo.
Se olharmos a fonte do Listmódulo OCaml , of_seqé definido como:
let[@tail_mod_cons] rec of_seq seq = match seq () with | Seq.Nil -> [] | Seq.Cons (x1, seq) -> begin match seq () with | Seq.Nil -> [x1] | Seq.Cons (x2, seq) -> x1 :: x2 :: of_seq seq end
Isso faz todo o sentido , exceto por que o trabalho extra é executado dentro da função em vez de escrever a função seguinte aparentemente mais direta?
let[@tail_mod_cons] rec of_seq seq =
match seq () with
| Seq.Nil -> []
| Seq.Cons (x1, seq) -> x1 :: of_seq seq
Que insight estou faltando para fazer isso fazer sentido?
Eu tenho essa consulta sql para construir uma tabela no Sqlite3, estou usando uma string multilinha que funciona bem.
let create_blog_table db =
let sql =
"
CREATE TABLE IF NOT EXISTS blog(
id INTEGER PRIMARY KEY AUTOINCREMENT,
author TEXT NOT NULL,
content TEXT NOT NULL);
"
in
match exec db sql with Rc.OK -> () | _ -> failwith "Error creating table"
Mas quando executo dune fmt(com o ocamlformat instalado) resulta no seguinte:
let create_blog_table db =
let sql =
"\n\
\ CREATE TABLE IF NOT EXISTS blog(\n\
\ id INTEGER PRIMARY KEY AUTOINCREMENT,\n\
\ author TEXT NOT NULL,\n\
\ content TEXT NOT NULL);\n\
\ "
in
match exec db sql with Rc.OK -> () | _ -> failwith "Error creating table"
Essa formatação é necessária ou desejável por algum motivo?
Se não, posso dizer para não fazer isso?
Encontrei a regra, break-string-literalsmas ela só permite autoounever
.ocamlformato
profile = default
version = 0.26.0
break-string-literals=auto