Prolog 将atom转换为大写（或小写）[SICStus]

我想使用以下谓词将小写atom转换为大写（反之亦然）：

to_upper([], []) :-
   !.
to_upper([LC|LCAtom], [U|UAtom]) :-
   UC is LC-32, 

   char_code(U, UC),  % <-
   % List = [UC|UAtom],

   to_upper(LCAtom, UAtom).
   % atom_codes(Result, List),

我的问题是输出必须是这样的

X='ABC.

not list，我想

atom\u code/2

解决这个prb，但哪一行必须被它们替换

---

帮助

经过一番努力，我找到了这个解决方案：

代码：

| ?- to_upper("abc", X).
X = ['A','B','C'] ? ;
no

%lowercase to uppercase 

to_upper(Atom,UAtom) :- atom_codes(Atom,CList),
                       ( foreach(C,CList),
                         fromto(Res,Out,In,[]) 
                         do
                            between(97,122,C),     % is_upper
                            C1 is C-32,
                            Out=[C1|In]
                        ),
                        atom_codes(UAtom,Res).


% uppercase to lowercase

to_lower(Atom,LAtom) :- atom_codes(Atom,CList),
                       ( foreach(C,CList),
                         fromto(Res,Out,In,[]) 
                         do
                            between(65,90,C),     % is_lower
                            C1 is C+32,
                            Out=[C1|In]
                        ),
                        atom_codes(LAtom,Res).

| ?- to_upper(abc,X).
X = 'ABC' ? ;
no

| ?- to_lower('ABC',X).
X = abc ? ;
no
| ?- 

结果：

| ?- to_upper("abc", X).
X = ['A','B','C'] ? ;
no

%lowercase to uppercase 

to_upper(Atom,UAtom) :- atom_codes(Atom,CList),
                       ( foreach(C,CList),
                         fromto(Res,Out,In,[]) 
                         do
                            between(97,122,C),     % is_upper
                            C1 is C-32,
                            Out=[C1|In]
                        ),
                        atom_codes(UAtom,Res).


% uppercase to lowercase

to_lower(Atom,LAtom) :- atom_codes(Atom,CList),
                       ( foreach(C,CList),
                         fromto(Res,Out,In,[]) 
                         do
                            between(65,90,C),     % is_lower
                            C1 is C+32,
                            Out=[C1|In]
                        ),
                        atom_codes(LAtom,Res).

| ?- to_upper(abc,X).
X = 'ABC' ? ;
no

| ?- to_lower('ABC',X).
X = abc ? ;
no
| ?- 

注意：随着to_降低/2，您需要将原子置于

''

编辑代码：

| ?- to_upper("abc", X).
X = ['A','B','C'] ? ;
no

%lowercase to uppercase 

to_upper(Atom,UAtom) :- atom_codes(Atom,CList),
                       ( foreach(C,CList),
                         fromto(Res,Out,In,[]) 
                         do
                            between(97,122,C),     % is_upper
                            C1 is C-32,
                            Out=[C1|In]
                        ),
                        atom_codes(UAtom,Res).


% uppercase to lowercase

to_lower(Atom,LAtom) :- atom_codes(Atom,CList),
                       ( foreach(C,CList),
                         fromto(Res,Out,In,[]) 
                         do
                            between(65,90,C),     % is_lower
                            C1 is C+32,
                            Out=[C1|In]
                        ),
                        atom_codes(LAtom,Res).

| ?- to_upper(abc,X).
X = 'ABC' ? ;
no

| ?- to_lower('ABC',X).
X = abc ? ;
no
| ?- 

变换原子结构

char_to_lower(L,UChar)  :-  % <=> char_to_lower(-32)
                            between(0'A, 0'Z, L)-> 
                            UChar is L+32 ; 
                            UChar=L.

atom_to_lower(Atom,Res) :-  % <=> atom_to_upper
                            atom_codes(Atom,Codes),
                            maplist(char_to_lower,Codes,LCodes),
                            atom_codes(Res,LCodes).

测试原子是否为小写

is_lower(Atom) :- \+is_upper(Atom),!.  % \+ <=> NOT(pred/N)

is\u lower（Atom）：-\+is\u upper（Atom），！.%\+非（pred/N）

从列表中获取上原子和下原子

get_upper(List,List_Upper) :- include(is_upper,List,List_Upper).

get_lower(List,List_Lower) :- include(is_lower,List,List_Lower).
                              % exclude(get_upper,List,List_Lower)


% get_upper_lower(+List,?ListUpper,?ListLower)

get_upper_lower(List, List_Upper,List_Lower) :- get_upper(List,List_Upper),
                                                 get_lower(List,List_Lower).
                                              % get_lower/2 <=> exclude(get_upper,List,List_Lower)

get\u upper（列表，列表上方）：-include（is\u upper，List，列表上方）。
get_lower（List，List_lower）：-包括（is_lower，List，List_lower）。
%排除（获取上部、列表、列表下部）
%获取上下（+列表、列表上、列表下）
get_upper_lower（列表，列表上方，列表下方）：-get_upper（列表，列表上方），
降低（列表，列表降低）。
%获取较低值/2排除（获取较高值、列表、列表较低值）

我在另一个答案中展示了清洁剂（imho）的可能性：

% if uppercase get lowercase
upper_lower(U, L) :-
  between(0'A, 0'Z, U), L is 0'a + U - 0'A.

make_lower(C, L) :- upper_lower(C, L) ; L = C.

可直接轻松使用或从实用程序模块导出。给它起个你喜欢的名字

?- maplist(make_lower, "UpperCase", Codes),format('~s~n', [Codes]).

注意：使用-so basic-maplist/N，我们应该能够使用更具声明性的CLP（FD）库：

上下（U，L）：-
U#>=0'A，U#=<0'Z，L#=U-0'A+0'A。

非常迫切。编写一个关系

upper\u lower/2

，就像@capelical那样。使用纯构造（如约束）使其在所有方向上都可用。@mat何时使用它？在char_to_lower/2中，“vis versa”是什么意思？“反之亦然”，可能吗？我补充道！完成了

|？-maplist（使_变低，“大写”，代码），格式（'~s~n'，[code]），！。大写代码=[1171112101114,99,97115101]；没有

，但是否可以使用此

格式（'~s~n'，[code]，Result）。

？如果我理解你的问题，原子代码（Result，code）应该可以工作。在SWI中，还有一种可能性是

格式（atom（结果），'~s'，[code]）

。不确定SICSTUS@capelical：我在手册SICS_4.3中找到了这一点<代码>格式（+控件，+参数）。格式（+流，+控件，+参数）。atom\u代码有什么问题/2？格式/3在这里似乎有些过分了。。。也许我没有满足你的使用要求。。。